projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'net-6.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net
[linux-block.git] / drivers / s390 / net / lcs.c
CommitLineData
ab9953ff 1// SPDX-License-Identifier: GPL-2.0+
1da177e4 2/*
1da177e4
LT		 3 * Linux for S/390 Lan Channel Station Network Driver
4 *
cbb2aec3
KDW		 5 * Copyright IBM Corp. 1999, 2009
6 * Author(s): Original Code written by
7 * DJ Barrow <djbarrow@de.ibm.com,barrow_dj@yahoo.com>
8 * Rewritten by
9 * Frank Pavlic <fpavlic@de.ibm.com> and
10 * Martin Schwidefsky <schwidefsky@de.ibm.com>
1da177e4
LT		 11 */
12
c99fc5da
KW		 13#define KMSG_COMPONENT "lcs"
14#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15
1da177e4
LT		 16#include <linux/module.h>
17#include <linux/if.h>
18#include <linux/netdevice.h>
19#include <linux/etherdevice.h>
1da177e4
LT		 20#include <linux/fddidevice.h>
21#include <linux/inetdevice.h>
22#include <linux/in.h>
23#include <linux/igmp.h>
24#include <linux/delay.h>
e5b5719b 25#include <linux/kthread.h>
5a0e3ad6 26#include <linux/slab.h>
1da177e4
LT		 27#include <net/arp.h>
28#include <net/ip.h>
29
30#include <asm/debug.h>
31#include <asm/idals.h>
32#include <asm/timex.h>
33#include <linux/device.h>
34#include <asm/ccwgroup.h>
35
36#include "lcs.h"
1da177e4
LT		 37
38
1abd2296 39#if !defined(CONFIG_ETHERNET) && !defined(CONFIG_FDDI)
1da177e4
LT		 40#error Cannot compile lcs.c without some net devices switched on.
41#endif
42
239686c1 43/*
1da177e4
LT		 44 * initialization string for output
45 */
1da177e4 46
e018ba1f 47static char version[] __initdata = "LCS driver";
0ca8cc6f 48
239686c1 49/*
0ca8cc6f
UB		 50 * the root device for lcs group devices
51 */
52static struct device *lcs_root_dev;
1da177e4 53
239686c1 54/*
1da177e4
LT		 55 * Some prototypes.
56 */
57static void lcs_tasklet(unsigned long);
4927b3f7 58static void lcs_start_kernel_thread(struct work_struct *);
1da177e4 59static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *);
801599b0 60#ifdef CONFIG_IP_MULTICAST
1da177e4 61static int lcs_send_delipm(struct lcs_card *, struct lcs_ipm_list *);
801599b0 62#endif /* CONFIG_IP_MULTICAST */
27eb5ac8 63static int lcs_recovery(void *ptr);
1da177e4 64
239686c1 65/*
1da177e4
LT		 66 * Debug Facility Stuff
67 */
0ca8cc6f 68static char debug_buffer[255];
1da177e4
LT		 69static debug_info_t *lcs_dbf_setup;
70static debug_info_t *lcs_dbf_trace;
71
239686c1 72/*
1da177e4
LT		 73 * LCS Debug Facility functions
74 */
75static void
76lcs_unregister_debug_facility(void)
77{
b646c08e
ME		 78 debug_unregister(lcs_dbf_setup);
79 debug_unregister(lcs_dbf_trace);
1da177e4
LT		 80}
81
82static int
83lcs_register_debug_facility(void)
84{
66a464db 85 lcs_dbf_setup = debug_register("lcs_setup", 2, 1, 8);
164b0fb1 86 lcs_dbf_trace = debug_register("lcs_trace", 4, 1, 8);
1da177e4 87 if (lcs_dbf_setup == NULL || lcs_dbf_trace == NULL) {
c99fc5da 88 pr_err("Not enough memory for debug facility.\n");
1da177e4
LT		 89 lcs_unregister_debug_facility();
90 return -ENOMEM;
91 }
92 debug_register_view(lcs_dbf_setup, &debug_hex_ascii_view);
0d613a27 93 debug_set_level(lcs_dbf_setup, 2);
1da177e4 94 debug_register_view(lcs_dbf_trace, &debug_hex_ascii_view);
0d613a27 95 debug_set_level(lcs_dbf_trace, 2);
1da177e4
LT		 96 return 0;
97}
98
239686c1 99/*
1da177e4
LT		 100 * Allocate io buffers.
101 */
102static int
103lcs_alloc_channel(struct lcs_channel *channel)
104{
105 int cnt;
106
107 LCS_DBF_TEXT(2, setup, "ichalloc");
108 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
109 /* alloc memory fo iobuffer */
88abaab4
ES		 110 channel->iob[cnt].data =
111 kzalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
1da177e4
LT		 112 if (channel->iob[cnt].data == NULL)
113 break;
9163bb2e 114 channel->iob[cnt].state = LCS_BUF_STATE_EMPTY;
1da177e4
LT		 115 }
116 if (cnt < LCS_NUM_BUFFS) {
117 /* Not all io buffers could be allocated. */
118 LCS_DBF_TEXT(2, setup, "echalloc");
119 while (cnt-- > 0)
120 kfree(channel->iob[cnt].data);
121 return -ENOMEM;
122 }
123 return 0;
124}
125
239686c1 126/*
1da177e4
LT		 127 * Free io buffers.
128 */
129static void
130lcs_free_channel(struct lcs_channel *channel)
131{
132 int cnt;
133
134 LCS_DBF_TEXT(2, setup, "ichfree");
135 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
17fd682e 136 kfree(channel->iob[cnt].data);
1da177e4
LT		 137 channel->iob[cnt].data = NULL;
138 }
139}
140
141/*
142 * Cleanup channel.
143 */
144static void
145lcs_cleanup_channel(struct lcs_channel *channel)
146{
147 LCS_DBF_TEXT(3, setup, "cleanch");
148 /* Kill write channel tasklets. */
149 tasklet_kill(&channel->irq_tasklet);
150 /* Free channel buffers. */
151 lcs_free_channel(channel);
152}
153
239686c1 154/*
1da177e4
LT		 155 * LCS free memory for card and channels.
156 */
157static void
158lcs_free_card(struct lcs_card *card)
159{
160 LCS_DBF_TEXT(2, setup, "remcard");
161 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
162 kfree(card);
163}
164
239686c1 165/*
1da177e4
LT		 166 * LCS alloc memory for card and channels
167 */
168static struct lcs_card *
169lcs_alloc_card(void)
170{
171 struct lcs_card *card;
172 int rc;
173
174 LCS_DBF_TEXT(2, setup, "alloclcs");
175
88abaab4 176 card = kzalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
1da177e4
LT		 177 if (card == NULL)
178 return NULL;
1da177e4
LT		 179 card->lan_type = LCS_FRAME_TYPE_AUTO;
180 card->pkt_seq = 0;
181 card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
182 /* Allocate io buffers for the read channel. */
183 rc = lcs_alloc_channel(&card->read);
184 if (rc){
185 LCS_DBF_TEXT(2, setup, "iccwerr");
186 lcs_free_card(card);
187 return NULL;
188 }
189 /* Allocate io buffers for the write channel. */
190 rc = lcs_alloc_channel(&card->write);
191 if (rc) {
192 LCS_DBF_TEXT(2, setup, "iccwerr");
193 lcs_cleanup_channel(&card->read);
194 lcs_free_card(card);
195 return NULL;
196 }
197
198#ifdef CONFIG_IP_MULTICAST
199 INIT_LIST_HEAD(&card->ipm_list);
200#endif
201 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
202 return card;
203}
204
205/*
206 * Setup read channel.
207 */
208static void
209lcs_setup_read_ccws(struct lcs_card *card)
210{
211 int cnt;
212
213 LCS_DBF_TEXT(2, setup, "ireadccw");
214 /* Setup read ccws. */
215 memset(card->read.ccws, 0, sizeof (struct ccw1) * (LCS_NUM_BUFFS + 1));
216 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
217 card->read.ccws[cnt].cmd_code = LCS_CCW_READ;
218 card->read.ccws[cnt].count = LCS_IOBUFFERSIZE;
219 card->read.ccws[cnt].flags =
220 CCW_FLAG_CC | CCW_FLAG_SLI | CCW_FLAG_PCI;
221 /*
222 * Note: we have allocated the buffer with GFP_DMA, so
223 * we do not need to do set_normalized_cda.
224 */
225 card->read.ccws[cnt].cda =
1bb7e8df 226 (__u32)virt_to_phys(card->read.iob[cnt].data);
1da177e4
LT		 227 ((struct lcs_header *)
228 card->read.iob[cnt].data)->offset = LCS_ILLEGAL_OFFSET;
229 card->read.iob[cnt].callback = lcs_get_frames_cb;
9163bb2e 230 card->read.iob[cnt].state = LCS_BUF_STATE_READY;
1da177e4
LT		 231 card->read.iob[cnt].count = LCS_IOBUFFERSIZE;
232 }
233 card->read.ccws[0].flags &= ~CCW_FLAG_PCI;
234 card->read.ccws[LCS_NUM_BUFFS - 1].flags &= ~CCW_FLAG_PCI;
235 card->read.ccws[LCS_NUM_BUFFS - 1].flags |= CCW_FLAG_SUSPEND;
236 /* Last ccw is a tic (transfer in channel). */
237 card->read.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
238 card->read.ccws[LCS_NUM_BUFFS].cda =
1bb7e8df 239 (__u32)virt_to_phys(card->read.ccws);
1da177e4 240 /* Setg initial state of the read channel. */
9163bb2e 241 card->read.state = LCS_CH_STATE_INIT;
1da177e4
LT		 242
243 card->read.io_idx = 0;
244 card->read.buf_idx = 0;
245}
246
247static void
248lcs_setup_read(struct lcs_card *card)
249{
250 LCS_DBF_TEXT(3, setup, "initread");
251
252 lcs_setup_read_ccws(card);
253 /* Initialize read channel tasklet. */
254 card->read.irq_tasklet.data = (unsigned long) &card->read;
255 card->read.irq_tasklet.func = lcs_tasklet;
256 /* Initialize waitqueue. */
257 init_waitqueue_head(&card->read.wait_q);
258}
259
260/*
261 * Setup write channel.
262 */
263static void
264lcs_setup_write_ccws(struct lcs_card *card)
265{
266 int cnt;
267
268 LCS_DBF_TEXT(3, setup, "iwritccw");
269 /* Setup write ccws. */
3c787475 270 memset(card->write.ccws, 0, sizeof(struct ccw1) * (LCS_NUM_BUFFS + 1));
1da177e4
LT		 271 for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
272 card->write.ccws[cnt].cmd_code = LCS_CCW_WRITE;
273 card->write.ccws[cnt].count = 0;
274 card->write.ccws[cnt].flags =
275 CCW_FLAG_SUSPEND | CCW_FLAG_CC | CCW_FLAG_SLI;
276 /*
277 * Note: we have allocated the buffer with GFP_DMA, so
278 * we do not need to do set_normalized_cda.
279 */
280 card->write.ccws[cnt].cda =
1bb7e8df 281 (__u32)virt_to_phys(card->write.iob[cnt].data);
1da177e4
LT		 282 }
283 /* Last ccw is a tic (transfer in channel). */
284 card->write.ccws[LCS_NUM_BUFFS].cmd_code = LCS_CCW_TRANSFER;
285 card->write.ccws[LCS_NUM_BUFFS].cda =
1bb7e8df 286 (__u32)virt_to_phys(card->write.ccws);
1da177e4 287 /* Set initial state of the write channel. */
9163bb2e 288 card->read.state = LCS_CH_STATE_INIT;
1da177e4
LT		 289
290 card->write.io_idx = 0;
291 card->write.buf_idx = 0;
292}
293
294static void
295lcs_setup_write(struct lcs_card *card)
296{
297 LCS_DBF_TEXT(3, setup, "initwrit");
298
299 lcs_setup_write_ccws(card);
300 /* Initialize write channel tasklet. */
301 card->write.irq_tasklet.data = (unsigned long) &card->write;
302 card->write.irq_tasklet.func = lcs_tasklet;
303 /* Initialize waitqueue. */
304 init_waitqueue_head(&card->write.wait_q);
305}
306
307static void
308lcs_set_allowed_threads(struct lcs_card *card, unsigned long threads)
309{
310 unsigned long flags;
311
312 spin_lock_irqsave(&card->mask_lock, flags);
313 card->thread_allowed_mask = threads;
314 spin_unlock_irqrestore(&card->mask_lock, flags);
315 wake_up(&card->wait_q);
316}
cef6ff22 317static int lcs_threads_running(struct lcs_card *card, unsigned long threads)
1da177e4
LT		 318{
319 unsigned long flags;
320 int rc = 0;
321
322 spin_lock_irqsave(&card->mask_lock, flags);
323 rc = (card->thread_running_mask & threads);
324 spin_unlock_irqrestore(&card->mask_lock, flags);
325 return rc;
326}
327
328static int
329lcs_wait_for_threads(struct lcs_card *card, unsigned long threads)
330{
331 return wait_event_interruptible(card->wait_q,
332 lcs_threads_running(card, threads) == 0);
333}
334
cef6ff22 335static int lcs_set_thread_start_bit(struct lcs_card *card, unsigned long thread)
1da177e4
LT		 336{
337 unsigned long flags;
338
339 spin_lock_irqsave(&card->mask_lock, flags);
340 if ( !(card->thread_allowed_mask & thread) ||
341 (card->thread_start_mask & thread) ) {
342 spin_unlock_irqrestore(&card->mask_lock, flags);
343 return -EPERM;
344 }
345 card->thread_start_mask |= thread;
346 spin_unlock_irqrestore(&card->mask_lock, flags);
347 return 0;
348}
349
350static void
351lcs_clear_thread_running_bit(struct lcs_card *card, unsigned long thread)
352{
353 unsigned long flags;
354
355 spin_lock_irqsave(&card->mask_lock, flags);
356 card->thread_running_mask &= ~thread;
357 spin_unlock_irqrestore(&card->mask_lock, flags);
358 wake_up(&card->wait_q);
359}
360
cef6ff22 361static int __lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
1da177e4
LT		 362{
363 unsigned long flags;
364 int rc = 0;
365
366 spin_lock_irqsave(&card->mask_lock, flags);
367 if (card->thread_start_mask & thread){
368 if ((card->thread_allowed_mask & thread) &&
369 !(card->thread_running_mask & thread)){
370 rc = 1;
371 card->thread_start_mask &= ~thread;
372 card->thread_running_mask |= thread;
373 } else
374 rc = -EPERM;
375 }
376 spin_unlock_irqrestore(&card->mask_lock, flags);
377 return rc;
378}
379
380static int
381lcs_do_run_thread(struct lcs_card *card, unsigned long thread)
382{
383 int rc = 0;
384 wait_event(card->wait_q,
385 (rc = __lcs_do_run_thread(card, thread)) >= 0);
386 return rc;
387}
388
389static int
390lcs_do_start_thread(struct lcs_card *card, unsigned long thread)
391{
392 unsigned long flags;
393 int rc = 0;
394
395 spin_lock_irqsave(&card->mask_lock, flags);
396 LCS_DBF_TEXT_(4, trace, " %02x%02x%02x",
397 (u8) card->thread_start_mask,
398 (u8) card->thread_allowed_mask,
399 (u8) card->thread_running_mask);
400 rc = (card->thread_start_mask & thread);
401 spin_unlock_irqrestore(&card->mask_lock, flags);
402 return rc;
403}
404
239686c1 405/*
1da177e4
LT		 406 * Initialize channels,card and state machines.
407 */
408static void
409lcs_setup_card(struct lcs_card *card)
410{
411 LCS_DBF_TEXT(2, setup, "initcard");
412 LCS_DBF_HEX(2, setup, &card, sizeof(void*));
413
414 lcs_setup_read(card);
415 lcs_setup_write(card);
416 /* Set cards initial state. */
417 card->state = DEV_STATE_DOWN;
418 card->tx_buffer = NULL;
419 card->tx_emitted = 0;
420
1da177e4
LT		 421 init_waitqueue_head(&card->wait_q);
422 spin_lock_init(&card->lock);
423 spin_lock_init(&card->ipm_lock);
424 spin_lock_init(&card->mask_lock);
425#ifdef CONFIG_IP_MULTICAST
426 INIT_LIST_HEAD(&card->ipm_list);
427#endif
428 INIT_LIST_HEAD(&card->lancmd_waiters);
429}
430
cef6ff22 431static void lcs_clear_multicast_list(struct lcs_card *card)
1da177e4
LT		 432{
433#ifdef CONFIG_IP_MULTICAST
434 struct lcs_ipm_list *ipm;
435 unsigned long flags;
436
437 /* Free multicast list. */
438 LCS_DBF_TEXT(3, setup, "clmclist");
439 spin_lock_irqsave(&card->ipm_lock, flags);
440 while (!list_empty(&card->ipm_list)){
441 ipm = list_entry(card->ipm_list.next,
442 struct lcs_ipm_list, list);
443 list_del(&ipm->list);
444 if (ipm->ipm_state != LCS_IPM_STATE_SET_REQUIRED){
445 spin_unlock_irqrestore(&card->ipm_lock, flags);
446 lcs_send_delipm(card, ipm);
447 spin_lock_irqsave(&card->ipm_lock, flags);
448 }
449 kfree(ipm);
450 }
451 spin_unlock_irqrestore(&card->ipm_lock, flags);
452#endif
453}
239686c1
HC		 454
455/*
1da177e4
LT		 456 * Cleanup channels,card and state machines.
457 */
458static void
459lcs_cleanup_card(struct lcs_card *card)
460{
461
462 LCS_DBF_TEXT(3, setup, "cleancrd");
463 LCS_DBF_HEX(2,setup,&card,sizeof(void*));
464
465 if (card->dev != NULL)
466 free_netdev(card->dev);
467 /* Cleanup channels. */
468 lcs_cleanup_channel(&card->write);
469 lcs_cleanup_channel(&card->read);
470}
471
239686c1 472/*
1da177e4
LT		 473 * Start channel.
474 */
475static int
476lcs_start_channel(struct lcs_channel *channel)
477{
478 unsigned long flags;
479 int rc;
480
2a0217d5 481 LCS_DBF_TEXT_(4, trace,"ssch%s", dev_name(&channel->ccwdev->dev));
1da177e4
LT		 482 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
483 rc = ccw_device_start(channel->ccwdev,
484 channel->ccws + channel->io_idx, 0, 0,
485 DOIO_DENY_PREFETCH | DOIO_ALLOW_SUSPEND);
486 if (rc == 0)
9163bb2e 487 channel->state = LCS_CH_STATE_RUNNING;
1da177e4
LT		 488 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
489 if (rc) {
2a0217d5
KS		 490 LCS_DBF_TEXT_(4,trace,"essh%s",
491 dev_name(&channel->ccwdev->dev));
c99fc5da
KW		 492 dev_err(&channel->ccwdev->dev,
493 "Starting an LCS device resulted in an error,"
494 " rc=%d!\n", rc);
1da177e4
LT		 495 }
496 return rc;
497}
498
499static int
500lcs_clear_channel(struct lcs_channel *channel)
501{
502 unsigned long flags;
503 int rc;
504
505 LCS_DBF_TEXT(4,trace,"clearch");
2a0217d5 506 LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
1da177e4 507 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
0506d5ba 508 rc = ccw_device_clear(channel->ccwdev, 0);
1da177e4
LT		 509 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
510 if (rc) {
2a0217d5
KS		 511 LCS_DBF_TEXT_(4, trace, "ecsc%s",
512 dev_name(&channel->ccwdev->dev));
1da177e4
LT		 513 return rc;
514 }
9163bb2e
UB		 515 wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_CLEARED));
516 channel->state = LCS_CH_STATE_STOPPED;
1da177e4
LT		 517 return rc;
518}
519
520
239686c1 521/*
1da177e4
LT		 522 * Stop channel.
523 */
524static int
525lcs_stop_channel(struct lcs_channel *channel)
526{
527 unsigned long flags;
528 int rc;
529
9163bb2e 530 if (channel->state == LCS_CH_STATE_STOPPED)
1da177e4
LT		 531 return 0;
532 LCS_DBF_TEXT(4,trace,"haltsch");
2a0217d5 533 LCS_DBF_TEXT_(4, trace, "%s", dev_name(&channel->ccwdev->dev));
9163bb2e 534 channel->state = LCS_CH_STATE_INIT;
1da177e4 535 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
0506d5ba 536 rc = ccw_device_halt(channel->ccwdev, 0);
1da177e4
LT		 537 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
538 if (rc) {
2a0217d5
KS		 539 LCS_DBF_TEXT_(4, trace, "ehsc%s",
540 dev_name(&channel->ccwdev->dev));
1da177e4
LT		 541 return rc;
542 }
543 /* Asynchronous halt initialted. Wait for its completion. */
9163bb2e 544 wait_event(channel->wait_q, (channel->state == LCS_CH_STATE_HALTED));
1da177e4
LT		 545 lcs_clear_channel(channel);
546 return 0;
547}
548
239686c1 549/*
1da177e4
LT		 550 * start read and write channel
551 */
552static int
553lcs_start_channels(struct lcs_card *card)
554{
555 int rc;
556
557 LCS_DBF_TEXT(2, trace, "chstart");
558 /* start read channel */
559 rc = lcs_start_channel(&card->read);
560 if (rc)
561 return rc;
562 /* start write channel */
563 rc = lcs_start_channel(&card->write);
564 if (rc)
565 lcs_stop_channel(&card->read);
566 return rc;
567}
568
239686c1 569/*
1da177e4
LT		 570 * stop read and write channel
571 */
572static int
573lcs_stop_channels(struct lcs_card *card)
574{
575 LCS_DBF_TEXT(2, trace, "chhalt");
576 lcs_stop_channel(&card->read);
577 lcs_stop_channel(&card->write);
578 return 0;
579}
580
239686c1 581/*
1da177e4
LT		 582 * Get empty buffer.
583 */
584static struct lcs_buffer *
585__lcs_get_buffer(struct lcs_channel *channel)
586{
587 int index;
588
589 LCS_DBF_TEXT(5, trace, "_getbuff");
590 index = channel->io_idx;
591 do {
9163bb2e
UB		 592 if (channel->iob[index].state == LCS_BUF_STATE_EMPTY) {
593 channel->iob[index].state = LCS_BUF_STATE_LOCKED;
1da177e4
LT		 594 return channel->iob + index;
595 }
596 index = (index + 1) & (LCS_NUM_BUFFS - 1);
597 } while (index != channel->io_idx);
598 return NULL;
599}
600
601static struct lcs_buffer *
602lcs_get_buffer(struct lcs_channel *channel)
603{
604 struct lcs_buffer *buffer;
605 unsigned long flags;
606
607 LCS_DBF_TEXT(5, trace, "getbuff");
608 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
609 buffer = __lcs_get_buffer(channel);
610 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
611 return buffer;
612}
613
239686c1 614/*
1da177e4
LT		 615 * Resume channel program if the channel is suspended.
616 */
617static int
618__lcs_resume_channel(struct lcs_channel *channel)
619{
620 int rc;
621
9163bb2e 622 if (channel->state != LCS_CH_STATE_SUSPENDED)
1da177e4
LT		 623 return 0;
624 if (channel->ccws[channel->io_idx].flags & CCW_FLAG_SUSPEND)
625 return 0;
2a0217d5 626 LCS_DBF_TEXT_(5, trace, "rsch%s", dev_name(&channel->ccwdev->dev));
1da177e4
LT		 627 rc = ccw_device_resume(channel->ccwdev);
628 if (rc) {
2a0217d5
KS		 629 LCS_DBF_TEXT_(4, trace, "ersc%s",
630 dev_name(&channel->ccwdev->dev));
c99fc5da
KW		 631 dev_err(&channel->ccwdev->dev,
632 "Sending data from the LCS device to the LAN failed"
633 " with rc=%d\n",rc);
1da177e4 634 } else
9163bb2e 635 channel->state = LCS_CH_STATE_RUNNING;
1da177e4
LT		 636 return rc;
637
638}
639
239686c1 640/*
1da177e4
LT		 641 * Make a buffer ready for processing.
642 */
cef6ff22 643static void __lcs_ready_buffer_bits(struct lcs_channel *channel, int index)
1da177e4
LT		 644{
645 int prev, next;
646
647 LCS_DBF_TEXT(5, trace, "rdybits");
648 prev = (index - 1) & (LCS_NUM_BUFFS - 1);
649 next = (index + 1) & (LCS_NUM_BUFFS - 1);
650 /* Check if we may clear the suspend bit of this buffer. */
651 if (channel->ccws[next].flags & CCW_FLAG_SUSPEND) {
652 /* Check if we have to set the PCI bit. */
653 if (!(channel->ccws[prev].flags & CCW_FLAG_SUSPEND))
654 /* Suspend bit of the previous buffer is not set. */
655 channel->ccws[index].flags |= CCW_FLAG_PCI;
656 /* Suspend bit of the next buffer is set. */
657 channel->ccws[index].flags &= ~CCW_FLAG_SUSPEND;
658 }
659}
660
661static int
662lcs_ready_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
663{
664 unsigned long flags;
665 int index, rc;
666
667 LCS_DBF_TEXT(5, trace, "rdybuff");
9163bb2e
UB		 668 BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
669 buffer->state != LCS_BUF_STATE_PROCESSED);
1da177e4 670 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
9163bb2e 671 buffer->state = LCS_BUF_STATE_READY;
1da177e4
LT		 672 index = buffer - channel->iob;
673 /* Set length. */
674 channel->ccws[index].count = buffer->count;
675 /* Check relevant PCI/suspend bits. */
676 __lcs_ready_buffer_bits(channel, index);
677 rc = __lcs_resume_channel(channel);
678 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
679 return rc;
680}
681
239686c1 682/*
1da177e4
LT		 683 * Mark the buffer as processed. Take care of the suspend bit
684 * of the previous buffer. This function is called from
685 * interrupt context, so the lock must not be taken.
686 */
687static int
688__lcs_processed_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
689{
690 int index, prev, next;
691
692 LCS_DBF_TEXT(5, trace, "prcsbuff");
9163bb2e
UB		 693 BUG_ON(buffer->state != LCS_BUF_STATE_READY);
694 buffer->state = LCS_BUF_STATE_PROCESSED;
1da177e4
LT		 695 index = buffer - channel->iob;
696 prev = (index - 1) & (LCS_NUM_BUFFS - 1);
697 next = (index + 1) & (LCS_NUM_BUFFS - 1);
698 /* Set the suspend bit and clear the PCI bit of this buffer. */
699 channel->ccws[index].flags |= CCW_FLAG_SUSPEND;
700 channel->ccws[index].flags &= ~CCW_FLAG_PCI;
701 /* Check the suspend bit of the previous buffer. */
9163bb2e 702 if (channel->iob[prev].state == LCS_BUF_STATE_READY) {
1da177e4
LT		 703 /*
704 * Previous buffer is in state ready. It might have
705 * happened in lcs_ready_buffer that the suspend bit
706 * has not been cleared to avoid an endless loop.
707 * Do it now.
708 */
709 __lcs_ready_buffer_bits(channel, prev);
710 }
711 /* Clear PCI bit of next buffer. */
712 channel->ccws[next].flags &= ~CCW_FLAG_PCI;
713 return __lcs_resume_channel(channel);
714}
715
239686c1 716/*
1da177e4
LT		 717 * Put a processed buffer back to state empty.
718 */
719static void
720lcs_release_buffer(struct lcs_channel *channel, struct lcs_buffer *buffer)
721{
722 unsigned long flags;
723
724 LCS_DBF_TEXT(5, trace, "relbuff");
9163bb2e
UB		 725 BUG_ON(buffer->state != LCS_BUF_STATE_LOCKED &&
726 buffer->state != LCS_BUF_STATE_PROCESSED);
1da177e4 727 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
9163bb2e 728 buffer->state = LCS_BUF_STATE_EMPTY;
1da177e4
LT		 729 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
730}
731
239686c1 732/*
1da177e4
LT		 733 * Get buffer for a lan command.
734 */
735static struct lcs_buffer *
736lcs_get_lancmd(struct lcs_card *card, int count)
737{
738 struct lcs_buffer *buffer;
739 struct lcs_cmd *cmd;
740
741 LCS_DBF_TEXT(4, trace, "getlncmd");
742 /* Get buffer and wait if none is available. */
743 wait_event(card->write.wait_q,
744 ((buffer = lcs_get_buffer(&card->write)) != NULL));
745 count += sizeof(struct lcs_header);
746 *(__u16 *)(buffer->data + count) = 0;
747 buffer->count = count + sizeof(__u16);
748 buffer->callback = lcs_release_buffer;
749 cmd = (struct lcs_cmd *) buffer->data;
750 cmd->offset = count;
751 cmd->type = LCS_FRAME_TYPE_CONTROL;
752 cmd->slot = 0;
753 return buffer;
754}
755
756
757static void
758lcs_get_reply(struct lcs_reply *reply)
759{
c380cd5a 760 refcount_inc(&reply->refcnt);
1da177e4
LT		 761}
762
763static void
764lcs_put_reply(struct lcs_reply *reply)
765{
c380cd5a 766 if (refcount_dec_and_test(&reply->refcnt))
1da177e4 767 kfree(reply);
1da177e4
LT		 768}
769
770static struct lcs_reply *
771lcs_alloc_reply(struct lcs_cmd *cmd)
772{
773 struct lcs_reply *reply;
774
775 LCS_DBF_TEXT(4, trace, "getreply");
776
88abaab4 777 reply = kzalloc(sizeof(struct lcs_reply), GFP_ATOMIC);
1da177e4
LT		 778 if (!reply)
779 return NULL;
c380cd5a 780 refcount_set(&reply->refcnt, 1);
1da177e4
LT		 781 reply->sequence_no = cmd->sequence_no;
782 reply->received = 0;
783 reply->rc = 0;
784 init_waitqueue_head(&reply->wait_q);
785
786 return reply;
787}
788
239686c1 789/*
1da177e4
LT		 790 * Notifier function for lancmd replies. Called from read irq.
791 */
792static void
793lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
794{
795 struct list_head *l, *n;
796 struct lcs_reply *reply;
797
798 LCS_DBF_TEXT(4, trace, "notiwait");
799 spin_lock(&card->lock);
800 list_for_each_safe(l, n, &card->lancmd_waiters) {
801 reply = list_entry(l, struct lcs_reply, list);
802 if (reply->sequence_no == cmd->sequence_no) {
803 lcs_get_reply(reply);
804 list_del_init(&reply->list);
805 if (reply->callback != NULL)
806 reply->callback(card, cmd);
807 reply->received = 1;
808 reply->rc = cmd->return_code;
809 wake_up(&reply->wait_q);
810 lcs_put_reply(reply);
811 break;
812 }
813 }
814 spin_unlock(&card->lock);
815}
816
239686c1 817/*
b595076a 818 * Emit buffer of a lan command.
1da177e4 819 */
2b67fc46 820static void
9c6c273a 821lcs_lancmd_timeout(struct timer_list *t)
1da177e4 822{
9c6c273a
KC		 823 struct lcs_reply *reply = from_timer(reply, t, timer);
824 struct lcs_reply *list_reply, *r;
1da177e4
LT		 825 unsigned long flags;
826
827 LCS_DBF_TEXT(4, trace, "timeout");
1da177e4
LT		 828 spin_lock_irqsave(&reply->card->lock, flags);
829 list_for_each_entry_safe(list_reply, r,
830 &reply->card->lancmd_waiters,list) {
831 if (reply == list_reply) {
832 lcs_get_reply(reply);
833 list_del_init(&reply->list);
834 spin_unlock_irqrestore(&reply->card->lock, flags);
835 reply->received = 1;
836 reply->rc = -ETIME;
837 wake_up(&reply->wait_q);
838 lcs_put_reply(reply);
839 return;
840 }
841 }
842 spin_unlock_irqrestore(&reply->card->lock, flags);
843}
844
845static int
846lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
847 void (*reply_callback)(struct lcs_card *, struct lcs_cmd *))
848{
849 struct lcs_reply *reply;
850 struct lcs_cmd *cmd;
1da177e4
LT		 851 unsigned long flags;
852 int rc;
853
854 LCS_DBF_TEXT(4, trace, "sendcmd");
855 cmd = (struct lcs_cmd *) buffer->data;
856 cmd->return_code = 0;
857 cmd->sequence_no = card->sequence_no++;
858 reply = lcs_alloc_reply(cmd);
859 if (!reply)
860 return -ENOMEM;
861 reply->callback = reply_callback;
862 reply->card = card;
863 spin_lock_irqsave(&card->lock, flags);
864 list_add_tail(&reply->list, &card->lancmd_waiters);
865 spin_unlock_irqrestore(&card->lock, flags);
866
867 buffer->callback = lcs_release_buffer;
868 rc = lcs_ready_buffer(&card->write, buffer);
869 if (rc)
870 return rc;
9c6c273a
KC		 871 timer_setup(&reply->timer, lcs_lancmd_timeout, 0);
872 mod_timer(&reply->timer, jiffies + HZ * card->lancmd_timeout);
1da177e4 873 wait_event(reply->wait_q, reply->received);
9c6c273a 874 del_timer_sync(&reply->timer);
1da177e4
LT		 875 LCS_DBF_TEXT_(4, trace, "rc:%d",reply->rc);
876 rc = reply->rc;
877 lcs_put_reply(reply);
878 return rc ? -EIO : 0;
879}
880
239686c1 881/*
1da177e4
LT		 882 * LCS startup command
883 */
884static int
885lcs_send_startup(struct lcs_card *card, __u8 initiator)
886{
887 struct lcs_buffer *buffer;
888 struct lcs_cmd *cmd;
889
890 LCS_DBF_TEXT(2, trace, "startup");
891 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
892 cmd = (struct lcs_cmd *) buffer->data;
893 cmd->cmd_code = LCS_CMD_STARTUP;
894 cmd->initiator = initiator;
895 cmd->cmd.lcs_startup.buff_size = LCS_IOBUFFERSIZE;
896 return lcs_send_lancmd(card, buffer, NULL);
897}
898
239686c1 899/*
1da177e4
LT		 900 * LCS shutdown command
901 */
902static int
903lcs_send_shutdown(struct lcs_card *card)
904{
905 struct lcs_buffer *buffer;
906 struct lcs_cmd *cmd;
907
908 LCS_DBF_TEXT(2, trace, "shutdown");
909 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
910 cmd = (struct lcs_cmd *) buffer->data;
911 cmd->cmd_code = LCS_CMD_SHUTDOWN;
912 cmd->initiator = LCS_INITIATOR_TCPIP;
913 return lcs_send_lancmd(card, buffer, NULL);
914}
915
239686c1 916/*
1da177e4
LT		 917 * LCS lanstat command
918 */
919static void
920__lcs_lanstat_cb(struct lcs_card *card, struct lcs_cmd *cmd)
921{
922 LCS_DBF_TEXT(2, trace, "statcb");
923 memcpy(card->mac, cmd->cmd.lcs_lanstat_cmd.mac_addr, LCS_MAC_LENGTH);
924}
925
926static int
927lcs_send_lanstat(struct lcs_card *card)
928{
929 struct lcs_buffer *buffer;
930 struct lcs_cmd *cmd;
931
932 LCS_DBF_TEXT(2,trace, "cmdstat");
933 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
934 cmd = (struct lcs_cmd *) buffer->data;
935 /* Setup lanstat command. */
936 cmd->cmd_code = LCS_CMD_LANSTAT;
937 cmd->initiator = LCS_INITIATOR_TCPIP;
938 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
939 cmd->cmd.lcs_std_cmd.portno = card->portno;
940 return lcs_send_lancmd(card, buffer, __lcs_lanstat_cb);
941}
942
239686c1 943/*
1da177e4
LT		 944 * send stoplan command
945 */
946static int
947lcs_send_stoplan(struct lcs_card *card, __u8 initiator)
948{
949 struct lcs_buffer *buffer;
950 struct lcs_cmd *cmd;
951
952 LCS_DBF_TEXT(2, trace, "cmdstpln");
953 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
954 cmd = (struct lcs_cmd *) buffer->data;
955 cmd->cmd_code = LCS_CMD_STOPLAN;
956 cmd->initiator = initiator;
957 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
958 cmd->cmd.lcs_std_cmd.portno = card->portno;
959 return lcs_send_lancmd(card, buffer, NULL);
960}
961
239686c1 962/*
1da177e4
LT		 963 * send startlan command
964 */
965static void
966__lcs_send_startlan_cb(struct lcs_card *card, struct lcs_cmd *cmd)
967{
968 LCS_DBF_TEXT(2, trace, "srtlancb");
969 card->lan_type = cmd->cmd.lcs_std_cmd.lan_type;
970 card->portno = cmd->cmd.lcs_std_cmd.portno;
971}
972
973static int
974lcs_send_startlan(struct lcs_card *card, __u8 initiator)
975{
976 struct lcs_buffer *buffer;
977 struct lcs_cmd *cmd;
978
979 LCS_DBF_TEXT(2, trace, "cmdstaln");
980 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
981 cmd = (struct lcs_cmd *) buffer->data;
982 cmd->cmd_code = LCS_CMD_STARTLAN;
983 cmd->initiator = initiator;
984 cmd->cmd.lcs_std_cmd.lan_type = card->lan_type;
985 cmd->cmd.lcs_std_cmd.portno = card->portno;
986 return lcs_send_lancmd(card, buffer, __lcs_send_startlan_cb);
987}
988
989#ifdef CONFIG_IP_MULTICAST
239686c1 990/*
1da177e4
LT		 991 * send setipm command (Multicast)
992 */
993static int
994lcs_send_setipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
995{
996 struct lcs_buffer *buffer;
997 struct lcs_cmd *cmd;
998
999 LCS_DBF_TEXT(2, trace, "cmdsetim");
1000 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1001 cmd = (struct lcs_cmd *) buffer->data;
1002 cmd->cmd_code = LCS_CMD_SETIPM;
1003 cmd->initiator = LCS_INITIATOR_TCPIP;
1004 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1005 cmd->cmd.lcs_qipassist.portno = card->portno;
1006 cmd->cmd.lcs_qipassist.version = 4;
1007 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1008 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1009 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1010 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1011 return lcs_send_lancmd(card, buffer, NULL);
1012}
1013
239686c1 1014/*
1da177e4
LT		 1015 * send delipm command (Multicast)
1016 */
1017static int
1018lcs_send_delipm(struct lcs_card *card,struct lcs_ipm_list *ipm_list)
1019{
1020 struct lcs_buffer *buffer;
1021 struct lcs_cmd *cmd;
1022
1023 LCS_DBF_TEXT(2, trace, "cmddelim");
1024 buffer = lcs_get_lancmd(card, LCS_MULTICAST_CMD_SIZE);
1025 cmd = (struct lcs_cmd *) buffer->data;
1026 cmd->cmd_code = LCS_CMD_DELIPM;
1027 cmd->initiator = LCS_INITIATOR_TCPIP;
1028 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1029 cmd->cmd.lcs_qipassist.portno = card->portno;
1030 cmd->cmd.lcs_qipassist.version = 4;
1031 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1032 memcpy(cmd->cmd.lcs_qipassist.lcs_ipass_ctlmsg.ip_mac_pair,
1033 &ipm_list->ipm, sizeof (struct lcs_ip_mac_pair));
1034 LCS_DBF_TEXT_(2, trace, "%x",ipm_list->ipm.ip_addr);
1035 return lcs_send_lancmd(card, buffer, NULL);
1036}
1037
239686c1 1038/*
1da177e4
LT		 1039 * check if multicast is supported by LCS
1040 */
1041static void
1042__lcs_check_multicast_cb(struct lcs_card *card, struct lcs_cmd *cmd)
1043{
1044 LCS_DBF_TEXT(2, trace, "chkmccb");
1045 card->ip_assists_supported =
1046 cmd->cmd.lcs_qipassist.ip_assists_supported;
1047 card->ip_assists_enabled =
1048 cmd->cmd.lcs_qipassist.ip_assists_enabled;
1049}
1050
1051static int
1052lcs_check_multicast_support(struct lcs_card *card)
1053{
1054 struct lcs_buffer *buffer;
1055 struct lcs_cmd *cmd;
1056 int rc;
1057
1058 LCS_DBF_TEXT(2, trace, "cmdqipa");
1059 /* Send query ipassist. */
1060 buffer = lcs_get_lancmd(card, LCS_STD_CMD_SIZE);
1061 cmd = (struct lcs_cmd *) buffer->data;
1062 cmd->cmd_code = LCS_CMD_QIPASSIST;
1063 cmd->initiator = LCS_INITIATOR_TCPIP;
1064 cmd->cmd.lcs_qipassist.lan_type = card->lan_type;
1065 cmd->cmd.lcs_qipassist.portno = card->portno;
1066 cmd->cmd.lcs_qipassist.version = 4;
1067 cmd->cmd.lcs_qipassist.num_ip_pairs = 1;
1068 rc = lcs_send_lancmd(card, buffer, __lcs_check_multicast_cb);
1069 if (rc != 0) {
c99fc5da 1070 pr_err("Query IPAssist failed. Assuming unsupported!\n");
1da177e4
LT		 1071 return -EOPNOTSUPP;
1072 }
1da177e4
LT		 1073 if (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT)
1074 return 0;
1075 return -EOPNOTSUPP;
1076}
1077
239686c1 1078/*
1da177e4
LT		 1079 * set or del multicast address on LCS card
1080 */
1081static void
1082lcs_fix_multicast_list(struct lcs_card *card)
1083{
1084 struct list_head failed_list;
1085 struct lcs_ipm_list *ipm, *tmp;
1086 unsigned long flags;
1087 int rc;
1088
1089 LCS_DBF_TEXT(4,trace, "fixipm");
1090 INIT_LIST_HEAD(&failed_list);
1091 spin_lock_irqsave(&card->ipm_lock, flags);
1092list_modified:
1093 list_for_each_entry_safe(ipm, tmp, &card->ipm_list, list){
1094 switch (ipm->ipm_state) {
1095 case LCS_IPM_STATE_SET_REQUIRED:
25985edc 1096 /* del from ipm_list so no one else can tamper with
1da177e4
LT		 1097 * this entry */
1098 list_del_init(&ipm->list);
1099 spin_unlock_irqrestore(&card->ipm_lock, flags);
1100 rc = lcs_send_setipm(card, ipm);
1101 spin_lock_irqsave(&card->ipm_lock, flags);
1102 if (rc) {
c99fc5da
KW		 1103 pr_info("Adding multicast address failed."
1104 " Table possibly full!\n");
1da177e4
LT		 1105 /* store ipm in failed list -> will be added
1106 * to ipm_list again, so a retry will be done
1107 * during the next call of this function */
1108 list_add_tail(&ipm->list, &failed_list);
1109 } else {
1110 ipm->ipm_state = LCS_IPM_STATE_ON_CARD;
1111 /* re-insert into ipm_list */
1112 list_add_tail(&ipm->list, &card->ipm_list);
1113 }
1114 goto list_modified;
1115 case LCS_IPM_STATE_DEL_REQUIRED:
1116 list_del(&ipm->list);
1117 spin_unlock_irqrestore(&card->ipm_lock, flags);
1118 lcs_send_delipm(card, ipm);
1119 spin_lock_irqsave(&card->ipm_lock, flags);
1120 kfree(ipm);
1121 goto list_modified;
1122 case LCS_IPM_STATE_ON_CARD:
1123 break;
1124 }
1125 }
1126 /* re-insert all entries from the failed_list into ipm_list */
179e0917
AM		 1127 list_for_each_entry_safe(ipm, tmp, &failed_list, list)
1128 list_move_tail(&ipm->list, &card->ipm_list);
1129
1da177e4 1130 spin_unlock_irqrestore(&card->ipm_lock, flags);
1da177e4
LT		 1131}
1132
239686c1 1133/*
1da177e4
LT		 1134 * get mac address for the relevant Multicast address
1135 */
1136static void
5a5a852e 1137lcs_get_mac_for_ipm(__be32 ipm, char *mac, struct net_device *dev)
1da177e4
LT		 1138{
1139 LCS_DBF_TEXT(4,trace, "getmac");
1abd2296 1140 ip_eth_mc_map(ipm, mac);
1da177e4
LT		 1141}
1142
239686c1 1143/*
1da177e4
LT		 1144 * function called by net device to handle multicast address relevant things
1145 */
cef6ff22
JW		 1146static void lcs_remove_mc_addresses(struct lcs_card *card,
1147 struct in_device *in4_dev)
1da177e4
LT		 1148{
1149 struct ip_mc_list *im4;
1150 struct list_head *l;
1151 struct lcs_ipm_list *ipm;
1152 unsigned long flags;
1153 char buf[MAX_ADDR_LEN];
1154
1155 LCS_DBF_TEXT(4, trace, "remmclst");
1156 spin_lock_irqsave(&card->ipm_lock, flags);
1157 list_for_each(l, &card->ipm_list) {
1158 ipm = list_entry(l, struct lcs_ipm_list, list);
f3aa3136
SS		 1159 for (im4 = rcu_dereference(in4_dev->mc_list);
1160 im4 != NULL; im4 = rcu_dereference(im4->next_rcu)) {
1da177e4
LT		 1161 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1162 if ( (ipm->ipm.ip_addr == im4->multiaddr) &&
1163 (memcmp(buf, &ipm->ipm.mac_addr,
1164 LCS_MAC_LENGTH) == 0) )
1165 break;
1166 }
1167 if (im4 == NULL)
1168 ipm->ipm_state = LCS_IPM_STATE_DEL_REQUIRED;
1169 }
1170 spin_unlock_irqrestore(&card->ipm_lock, flags);
1171}
1172
cef6ff22
JW		 1173static struct lcs_ipm_list *lcs_check_addr_entry(struct lcs_card *card,
1174 struct ip_mc_list *im4,
1175 char *buf)
1da177e4
LT		 1176{
1177 struct lcs_ipm_list *tmp, *ipm = NULL;
1178 struct list_head *l;
1179 unsigned long flags;
1180
1181 LCS_DBF_TEXT(4, trace, "chkmcent");
1182 spin_lock_irqsave(&card->ipm_lock, flags);
1183 list_for_each(l, &card->ipm_list) {
1184 tmp = list_entry(l, struct lcs_ipm_list, list);
1185 if ( (tmp->ipm.ip_addr == im4->multiaddr) &&
1186 (memcmp(buf, &tmp->ipm.mac_addr,
1187 LCS_MAC_LENGTH) == 0) ) {
1188 ipm = tmp;
1189 break;
1190 }
1191 }
1192 spin_unlock_irqrestore(&card->ipm_lock, flags);
1193 return ipm;
1194}
1195
cef6ff22
JW		 1196static void lcs_set_mc_addresses(struct lcs_card *card,
1197 struct in_device *in4_dev)
1da177e4
LT		 1198{
1199
1200 struct ip_mc_list *im4;
1201 struct lcs_ipm_list *ipm;
1202 char buf[MAX_ADDR_LEN];
1203 unsigned long flags;
1204
1205 LCS_DBF_TEXT(4, trace, "setmclst");
f3aa3136
SS		 1206 for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1207 im4 = rcu_dereference(im4->next_rcu)) {
1da177e4
LT		 1208 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
1209 ipm = lcs_check_addr_entry(card, im4, buf);
1210 if (ipm != NULL)
1211 continue; /* Address already in list. */
ae57b20a 1212 ipm = kzalloc(sizeof(struct lcs_ipm_list), GFP_ATOMIC);
1da177e4 1213 if (ipm == NULL) {
c99fc5da
KW		 1214 pr_info("Not enough memory to add"
1215 " new multicast entry!\n");
1da177e4
LT		 1216 break;
1217 }
1da177e4
LT		 1218 memcpy(&ipm->ipm.mac_addr, buf, LCS_MAC_LENGTH);
1219 ipm->ipm.ip_addr = im4->multiaddr;
1220 ipm->ipm_state = LCS_IPM_STATE_SET_REQUIRED;
1221 spin_lock_irqsave(&card->ipm_lock, flags);
27eb5ac8 1222 LCS_DBF_HEX(2,trace,&ipm->ipm.ip_addr,4);
1da177e4
LT		 1223 list_add(&ipm->list, &card->ipm_list);
1224 spin_unlock_irqrestore(&card->ipm_lock, flags);
1225 }
1226}
1227
1228static int
1229lcs_register_mc_addresses(void *data)
1230{
1231 struct lcs_card *card;
1232 struct in_device *in4_dev;
1233
1234 card = (struct lcs_card *) data;
1da177e4
LT		 1235
1236 if (!lcs_do_run_thread(card, LCS_SET_MC_THREAD))
1237 return 0;
1238 LCS_DBF_TEXT(4, trace, "regmulti");
1239
1240 in4_dev = in_dev_get(card->dev);
1241 if (in4_dev == NULL)
1242 goto out;
f3aa3136 1243 rcu_read_lock();
1da177e4
LT		 1244 lcs_remove_mc_addresses(card,in4_dev);
1245 lcs_set_mc_addresses(card, in4_dev);
f3aa3136 1246 rcu_read_unlock();
1da177e4
LT		 1247 in_dev_put(in4_dev);
1248
27eb5ac8
KW		 1249 netif_carrier_off(card->dev);
1250 netif_tx_disable(card->dev);
1251 wait_event(card->write.wait_q,
9163bb2e 1252 (card->write.state != LCS_CH_STATE_RUNNING));
1da177e4 1253 lcs_fix_multicast_list(card);
27eb5ac8
KW		 1254 if (card->state == DEV_STATE_UP) {
1255 netif_carrier_on(card->dev);
1256 netif_wake_queue(card->dev);
1257 }
1da177e4
LT		 1258out:
1259 lcs_clear_thread_running_bit(card, LCS_SET_MC_THREAD);
1260 return 0;
1261}
801599b0
HC		 1262#endif /* CONFIG_IP_MULTICAST */
1263
239686c1 1264/*
1da177e4
LT		 1265 * function called by net device to
1266 * handle multicast address relevant things
1267 */
1268static void
1269lcs_set_multicast_list(struct net_device *dev)
1270{
801599b0 1271#ifdef CONFIG_IP_MULTICAST
1da177e4
LT		 1272 struct lcs_card *card;
1273
1274 LCS_DBF_TEXT(4, trace, "setmulti");
ad660e2f 1275 card = (struct lcs_card *) dev->ml_priv;
1da177e4 1276
e82b0f2c 1277 if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD))
1da177e4 1278 schedule_work(&card->kernel_thread_starter);
1da177e4 1279#endif /* CONFIG_IP_MULTICAST */
801599b0 1280}
1da177e4
LT		 1281
1282static long
1283lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
1284{
1285 if (!IS_ERR(irb))
1286 return 0;
1287
1288 switch (PTR_ERR(irb)) {
1289 case -EIO:
c99fc5da
KW		 1290 dev_warn(&cdev->dev,
1291 "An I/O-error occurred on the LCS device\n");
1da177e4
LT		 1292 LCS_DBF_TEXT(2, trace, "ckirberr");
1293 LCS_DBF_TEXT_(2, trace, " rc%d", -EIO);
1294 break;
1295 case -ETIMEDOUT:
c99fc5da
KW		 1296 dev_warn(&cdev->dev,
1297 "A command timed out on the LCS device\n");
1da177e4
LT		 1298 LCS_DBF_TEXT(2, trace, "ckirberr");
1299 LCS_DBF_TEXT_(2, trace, " rc%d", -ETIMEDOUT);
1300 break;
1301 default:
c99fc5da
KW		 1302 dev_warn(&cdev->dev,
1303 "An error occurred on the LCS device, rc=%ld\n",
1304 PTR_ERR(irb));
1da177e4
LT		 1305 LCS_DBF_TEXT(2, trace, "ckirberr");
1306 LCS_DBF_TEXT(2, trace, " rc???");
1307 }
1308 return PTR_ERR(irb);
1309}
1310
27eb5ac8
KW		 1311static int
1312lcs_get_problem(struct ccw_device *cdev, struct irb *irb)
1313{
1314 int dstat, cstat;
1315 char *sense;
1316
1317 sense = (char *) irb->ecw;
23d805b6
PO		 1318 cstat = irb->scsw.cmd.cstat;
1319 dstat = irb->scsw.cmd.dstat;
27eb5ac8
KW		 1320
1321 if (cstat & (SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK |
1322 SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK |
1323 SCHN_STAT_PROT_CHECK | SCHN_STAT_PROG_CHECK)) {
1324 LCS_DBF_TEXT(2, trace, "CGENCHK");
1325 return 1;
1326 }
1327 if (dstat & DEV_STAT_UNIT_CHECK) {
1328 if (sense[LCS_SENSE_BYTE_1] &
1329 LCS_SENSE_RESETTING_EVENT) {
1330 LCS_DBF_TEXT(2, trace, "REVIND");
1331 return 1;
1332 }
1333 if (sense[LCS_SENSE_BYTE_0] &
1334 LCS_SENSE_CMD_REJECT) {
1335 LCS_DBF_TEXT(2, trace, "CMDREJ");
1336 return 0;
1337 }
1338 if ((!sense[LCS_SENSE_BYTE_0]) &&
1339 (!sense[LCS_SENSE_BYTE_1]) &&
1340 (!sense[LCS_SENSE_BYTE_2]) &&
1341 (!sense[LCS_SENSE_BYTE_3])) {
1342 LCS_DBF_TEXT(2, trace, "ZEROSEN");
1343 return 0;
1344 }
1345 LCS_DBF_TEXT(2, trace, "DGENCHK");
1346 return 1;
1347 }
1348 return 0;
1349}
1350
2b67fc46 1351static void
27eb5ac8
KW		 1352lcs_schedule_recovery(struct lcs_card *card)
1353{
1354 LCS_DBF_TEXT(2, trace, "startrec");
1355 if (!lcs_set_thread_start_bit(card, LCS_RECOVERY_THREAD))
1356 schedule_work(&card->kernel_thread_starter);
1357}
1da177e4 1358
239686c1 1359/*
1da177e4
LT		 1360 * IRQ Handler for LCS channels
1361 */
1362static void
1363lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1364{
1365 struct lcs_card *card;
1366 struct lcs_channel *channel;
27eb5ac8
KW		 1367 int rc, index;
1368 int cstat, dstat;
1da177e4
LT		 1369
1370 if (lcs_check_irb_error(cdev, irb))
1371 return;
1372
1373 card = CARD_FROM_DEV(cdev);
1374 if (card->read.ccwdev == cdev)
1375 channel = &card->read;
1376 else
1377 channel = &card->write;
1378
23d805b6
PO		 1379 cstat = irb->scsw.cmd.cstat;
1380 dstat = irb->scsw.cmd.dstat;
2a0217d5 1381 LCS_DBF_TEXT_(5, trace, "Rint%s", dev_name(&cdev->dev));
23d805b6
PO		 1382 LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.cstat,
1383 irb->scsw.cmd.dstat);
1384 LCS_DBF_TEXT_(5, trace, "%4x%4x", irb->scsw.cmd.fctl,
1385 irb->scsw.cmd.actl);
1da177e4 1386
27eb5ac8
KW		 1387 /* Check for channel and device errors presented */
1388 rc = lcs_get_problem(cdev, irb);
1389 if (rc || (dstat & DEV_STAT_UNIT_EXCEP)) {
c99fc5da
KW		 1390 dev_warn(&cdev->dev,
1391 "The LCS device stopped because of an error,"
1392 " dstat=0x%X, cstat=0x%X \n",
1393 dstat, cstat);
27eb5ac8 1394 if (rc) {
59579da3 1395 channel->state = LCS_CH_STATE_ERROR;
27eb5ac8
KW		 1396 }
1397 }
59579da3
KW		 1398 if (channel->state == LCS_CH_STATE_ERROR) {
1399 lcs_schedule_recovery(card);
1400 wake_up(&card->wait_q);
1401 return;
1402 }
1da177e4 1403 /* How far in the ccw chain have we processed? */
9163bb2e 1404 if ((channel->state != LCS_CH_STATE_INIT) &&
9b3b9ab6
KW		 1405 (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
1406 (irb->scsw.cmd.cpa != 0)) {
23d805b6 1407 index = (struct ccw1 *) __va((addr_t) irb->scsw.cmd.cpa)
1da177e4 1408 - channel->ccws;
23d805b6
PO		 1409 if ((irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED) ||
1410 (irb->scsw.cmd.cstat & SCHN_STAT_PCI))
1da177e4
LT		 1411 /* Bloody io subsystem tells us lies about cpa... */
1412 index = (index - 1) & (LCS_NUM_BUFFS - 1);
1413 while (channel->io_idx != index) {
1414 __lcs_processed_buffer(channel,
1415 channel->iob + channel->io_idx);
1416 channel->io_idx =
1417 (channel->io_idx + 1) & (LCS_NUM_BUFFS - 1);
1418 }
1419 }
1420
23d805b6
PO		 1421 if ((irb->scsw.cmd.dstat & DEV_STAT_DEV_END) ||
1422 (irb->scsw.cmd.dstat & DEV_STAT_CHN_END) ||
1423 (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK))
1da177e4 1424 /* Mark channel as stopped. */
9163bb2e 1425 channel->state = LCS_CH_STATE_STOPPED;
23d805b6 1426 else if (irb->scsw.cmd.actl & SCSW_ACTL_SUSPENDED)
1da177e4 1427 /* CCW execution stopped on a suspend bit. */
9163bb2e 1428 channel->state = LCS_CH_STATE_SUSPENDED;
23d805b6
PO		 1429 if (irb->scsw.cmd.fctl & SCSW_FCTL_HALT_FUNC) {
1430 if (irb->scsw.cmd.cc != 0) {
0506d5ba 1431 ccw_device_halt(channel->ccwdev, 0);
1da177e4
LT		 1432 return;
1433 }
1434 /* The channel has been stopped by halt_IO. */
9163bb2e 1435 channel->state = LCS_CH_STATE_HALTED;
1da177e4 1436 }
23d805b6 1437 if (irb->scsw.cmd.fctl & SCSW_FCTL_CLEAR_FUNC)
9163bb2e 1438 channel->state = LCS_CH_STATE_CLEARED;
1da177e4
LT		 1439 /* Do the rest in the tasklet. */
1440 tasklet_schedule(&channel->irq_tasklet);
1441}
1442
239686c1 1443/*
1da177e4
LT		 1444 * Tasklet for IRQ handler
1445 */
1446static void
1447lcs_tasklet(unsigned long data)
1448{
1449 unsigned long flags;
1450 struct lcs_channel *channel;
1451 struct lcs_buffer *iob;
1452 int buf_idx;
1da177e4
LT		 1453
1454 channel = (struct lcs_channel *) data;
2a0217d5 1455 LCS_DBF_TEXT_(5, trace, "tlet%s", dev_name(&channel->ccwdev->dev));
1da177e4
LT		 1456
1457 /* Check for processed buffers. */
1458 iob = channel->iob;
1459 buf_idx = channel->buf_idx;
9163bb2e 1460 while (iob[buf_idx].state == LCS_BUF_STATE_PROCESSED) {
1da177e4
LT		 1461 /* Do the callback thing. */
1462 if (iob[buf_idx].callback != NULL)
1463 iob[buf_idx].callback(channel, iob + buf_idx);
1464 buf_idx = (buf_idx + 1) & (LCS_NUM_BUFFS - 1);
1465 }
1466 channel->buf_idx = buf_idx;
1467
9163bb2e 1468 if (channel->state == LCS_CH_STATE_STOPPED)
424f73b3 1469 lcs_start_channel(channel);
1da177e4 1470 spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
9163bb2e 1471 if (channel->state == LCS_CH_STATE_SUSPENDED &&
424f73b3
HC		 1472 channel->iob[channel->io_idx].state == LCS_BUF_STATE_READY)
1473 __lcs_resume_channel(channel);
1da177e4
LT		 1474 spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
1475
1476 /* Something happened on the channel. Wake up waiters. */
1477 wake_up(&channel->wait_q);
1478}
1479
239686c1 1480/*
1da177e4
LT		 1481 * Finish current tx buffer and make it ready for transmit.
1482 */
1483static void
1484__lcs_emit_txbuffer(struct lcs_card *card)
1485{
1486 LCS_DBF_TEXT(5, trace, "emittx");
1487 *(__u16 *)(card->tx_buffer->data + card->tx_buffer->count) = 0;
1488 card->tx_buffer->count += 2;
1489 lcs_ready_buffer(&card->write, card->tx_buffer);
1490 card->tx_buffer = NULL;
1491 card->tx_emitted++;
1492}
1493
239686c1 1494/*
1da177e4
LT		 1495 * Callback for finished tx buffers.
1496 */
1497static void
1498lcs_txbuffer_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1499{
1500 struct lcs_card *card;
1501
1502 LCS_DBF_TEXT(5, trace, "txbuffcb");
1503 /* Put buffer back to pool. */
1504 lcs_release_buffer(channel, buffer);
b385a144 1505 card = container_of(channel, struct lcs_card, write);
27eb5ac8 1506 if (netif_queue_stopped(card->dev) && netif_carrier_ok(card->dev))
0d613a27 1507 netif_wake_queue(card->dev);
1da177e4
LT		 1508 spin_lock(&card->lock);
1509 card->tx_emitted--;
1510 if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1511 /*
1512 * Last running tx buffer has finished. Submit partially
1513 * filled current buffer.
1514 */
1515 __lcs_emit_txbuffer(card);
1516 spin_unlock(&card->lock);
1517}
1518
239686c1 1519/*
1da177e4
LT		 1520 * Packet transmit function called by network stack
1521 */
bb16db83
NC		 1522static netdev_tx_t __lcs_start_xmit(struct lcs_card *card, struct sk_buff *skb,
1523 struct net_device *dev)
1da177e4
LT		 1524{
1525 struct lcs_header *header;
ec634fe3 1526 int rc = NETDEV_TX_OK;
1da177e4
LT		 1527
1528 LCS_DBF_TEXT(5, trace, "hardxmit");
1529 if (skb == NULL) {
1530 card->stats.tx_dropped++;
1531 card->stats.tx_errors++;
ec634fe3 1532 return NETDEV_TX_OK;
1da177e4
LT		 1533 }
1534 if (card->state != DEV_STATE_UP) {
1535 dev_kfree_skb(skb);
1536 card->stats.tx_dropped++;
1537 card->stats.tx_errors++;
1538 card->stats.tx_carrier_errors++;
ec634fe3 1539 return NETDEV_TX_OK;
1da177e4 1540 }
27eb5ac8
KW		 1541 if (skb->protocol == htons(ETH_P_IPV6)) {
1542 dev_kfree_skb(skb);
ec634fe3 1543 return NETDEV_TX_OK;
27eb5ac8 1544 }
0d613a27
FP		 1545 netif_stop_queue(card->dev);
1546 spin_lock(&card->lock);
1da177e4
LT		 1547 if (card->tx_buffer != NULL &&
1548 card->tx_buffer->count + sizeof(struct lcs_header) +
1549 skb->len + sizeof(u16) > LCS_IOBUFFERSIZE)
1550 /* skb too big for current tx buffer. */
1551 __lcs_emit_txbuffer(card);
1552 if (card->tx_buffer == NULL) {
1553 /* Get new tx buffer */
1554 card->tx_buffer = lcs_get_buffer(&card->write);
1555 if (card->tx_buffer == NULL) {
1556 card->stats.tx_dropped++;
9e669d32 1557 rc = NETDEV_TX_BUSY;
0d613a27 1558 goto out;
1da177e4
LT		 1559 }
1560 card->tx_buffer->callback = lcs_txbuffer_cb;
1561 card->tx_buffer->count = 0;
1562 }
1563 header = (struct lcs_header *)
1564 (card->tx_buffer->data + card->tx_buffer->count);
1565 card->tx_buffer->count += skb->len + sizeof(struct lcs_header);
1566 header->offset = card->tx_buffer->count;
1567 header->type = card->lan_type;
1568 header->slot = card->portno;
d626f62b 1569 skb_copy_from_linear_data(skb, header + 1, skb->len);
0d613a27 1570 spin_unlock(&card->lock);
1da177e4
LT		 1571 card->stats.tx_bytes += skb->len;
1572 card->stats.tx_packets++;
1573 dev_kfree_skb(skb);
0d613a27
FP		 1574 netif_wake_queue(card->dev);
1575 spin_lock(&card->lock);
1576 if (card->tx_emitted <= 0 && card->tx_buffer != NULL)
1da177e4
LT		 1577 /* If this is the first tx buffer emit it immediately. */
1578 __lcs_emit_txbuffer(card);
0d613a27
FP		 1579out:
1580 spin_unlock(&card->lock);
1581 return rc;
1da177e4
LT		 1582}
1583
bb16db83 1584static netdev_tx_t lcs_start_xmit(struct sk_buff *skb, struct net_device *dev)
1da177e4
LT		 1585{
1586 struct lcs_card *card;
1587 int rc;
1588
1589 LCS_DBF_TEXT(5, trace, "pktxmit");
ad660e2f 1590 card = (struct lcs_card *) dev->ml_priv;
1da177e4 1591 rc = __lcs_start_xmit(card, skb, dev);
1da177e4
LT		 1592 return rc;
1593}
1594
239686c1 1595/*
1da177e4
LT		 1596 * send startlan and lanstat command to make LCS device ready
1597 */
1598static int
1599lcs_startlan_auto(struct lcs_card *card)
1600{
1601 int rc;
1602
1603 LCS_DBF_TEXT(2, trace, "strtauto");
1e495701 1604#ifdef CONFIG_ETHERNET
1da177e4
LT		 1605 card->lan_type = LCS_FRAME_TYPE_ENET;
1606 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1607 if (rc == 0)
1608 return 0;
1609
1610#endif
1da177e4
LT		 1611#ifdef CONFIG_FDDI
1612 card->lan_type = LCS_FRAME_TYPE_FDDI;
1613 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1614 if (rc == 0)
1615 return 0;
1616#endif
1617 return -EIO;
1618}
1619
1620static int
1621lcs_startlan(struct lcs_card *card)
1622{
1623 int rc, i;
1624
1625 LCS_DBF_TEXT(2, trace, "startlan");
1626 rc = 0;
1627 if (card->portno != LCS_INVALID_PORT_NO) {
1628 if (card->lan_type == LCS_FRAME_TYPE_AUTO)
1629 rc = lcs_startlan_auto(card);
1630 else
1631 rc = lcs_send_startlan(card, LCS_INITIATOR_TCPIP);
1632 } else {
1633 for (i = 0; i <= 16; i++) {
1634 card->portno = i;
1635 if (card->lan_type != LCS_FRAME_TYPE_AUTO)
1636 rc = lcs_send_startlan(card,
1637 LCS_INITIATOR_TCPIP);
1638 else
1639 /* autodetecting lan type */
1640 rc = lcs_startlan_auto(card);
1641 if (rc == 0)
1642 break;
1643 }
1644 }
1645 if (rc == 0)
1646 return lcs_send_lanstat(card);
1647 return rc;
1648}
1649
239686c1 1650/*
1da177e4
LT		 1651 * LCS detect function
1652 * setup channels and make them I/O ready
1653 */
1654static int
1655lcs_detect(struct lcs_card *card)
1656{
1657 int rc = 0;
1658
1659 LCS_DBF_TEXT(2, setup, "lcsdetct");
1660 /* start/reset card */
1661 if (card->dev)
1662 netif_stop_queue(card->dev);
1663 rc = lcs_stop_channels(card);
1664 if (rc == 0) {
1665 rc = lcs_start_channels(card);
1666 if (rc == 0) {
1667 rc = lcs_send_startup(card, LCS_INITIATOR_TCPIP);
1668 if (rc == 0)
1669 rc = lcs_startlan(card);
1670 }
1671 }
1672 if (rc == 0) {
1673 card->state = DEV_STATE_UP;
1674 } else {
1675 card->state = DEV_STATE_DOWN;
9163bb2e
UB		 1676 card->write.state = LCS_CH_STATE_INIT;
1677 card->read.state = LCS_CH_STATE_INIT;
1da177e4
LT		 1678 }
1679 return rc;
1680}
1681
239686c1 1682/*
1da177e4
LT		 1683 * LCS Stop card
1684 */
1685static int
1686lcs_stopcard(struct lcs_card *card)
1687{
1688 int rc;
1689
1690 LCS_DBF_TEXT(3, setup, "stopcard");
1691
9163bb2e
UB		 1692 if (card->read.state != LCS_CH_STATE_STOPPED &&
1693 card->write.state != LCS_CH_STATE_STOPPED &&
59579da3
KW		 1694 card->read.state != LCS_CH_STATE_ERROR &&
1695 card->write.state != LCS_CH_STATE_ERROR &&
1da177e4
LT		 1696 card->state == DEV_STATE_UP) {
1697 lcs_clear_multicast_list(card);
1698 rc = lcs_send_stoplan(card,LCS_INITIATOR_TCPIP);
1699 rc = lcs_send_shutdown(card);
1700 }
1701 rc = lcs_stop_channels(card);
1702 card->state = DEV_STATE_DOWN;
1703
1704 return rc;
1705}
1706
239686c1 1707/*
1da177e4
LT		 1708 * Kernel Thread helper functions for LGW initiated commands
1709 */
1710static void
4927b3f7 1711lcs_start_kernel_thread(struct work_struct *work)
1da177e4 1712{
4927b3f7 1713 struct lcs_card *card = container_of(work, struct lcs_card, kernel_thread_starter);
1da177e4 1714 LCS_DBF_TEXT(5, trace, "krnthrd");
27eb5ac8 1715 if (lcs_do_start_thread(card, LCS_RECOVERY_THREAD))
e5b5719b 1716 kthread_run(lcs_recovery, card, "lcs_recover");
1da177e4
LT		 1717#ifdef CONFIG_IP_MULTICAST
1718 if (lcs_do_start_thread(card, LCS_SET_MC_THREAD))
e5b5719b 1719 kthread_run(lcs_register_mc_addresses, card, "regipm");
1da177e4
LT		 1720#endif
1721}
1722
239686c1 1723/*
1da177e4
LT		 1724 * Process control frames.
1725 */
1726static void
1727lcs_get_control(struct lcs_card *card, struct lcs_cmd *cmd)
1728{
1729 LCS_DBF_TEXT(5, trace, "getctrl");
1730 if (cmd->initiator == LCS_INITIATOR_LGW) {
1731 switch(cmd->cmd_code) {
1732 case LCS_CMD_STARTUP:
1da177e4 1733 case LCS_CMD_STARTLAN:
27eb5ac8 1734 lcs_schedule_recovery(card);
1da177e4
LT		 1735 break;
1736 case LCS_CMD_STOPLAN:
671bb35c
AW		 1737 if (card->dev) {
1738 pr_warn("Stoplan for %s initiated by LGW\n",
1739 card->dev->name);
27eb5ac8 1740 netif_carrier_off(card->dev);
671bb35c 1741 }
1da177e4
LT		 1742 break;
1743 default:
6b648063 1744 LCS_DBF_TEXT(5, trace, "noLGWcmd");
1da177e4
LT		 1745 break;
1746 }
1747 } else
1748 lcs_notify_lancmd_waiters(card, cmd);
1749}
1750
239686c1 1751/*
1da177e4
LT		 1752 * Unpack network packet.
1753 */
1754static void
1755lcs_get_skb(struct lcs_card *card, char *skb_data, unsigned int skb_len)
1756{
1757 struct sk_buff *skb;
1758
1759 LCS_DBF_TEXT(5, trace, "getskb");
1760 if (card->dev == NULL ||
1761 card->state != DEV_STATE_UP)
1762 /* The card isn't up. Ignore the packet. */
1763 return;
1764
1765 skb = dev_alloc_skb(skb_len);
1766 if (skb == NULL) {
c99fc5da
KW		 1767 dev_err(&card->dev->dev,
1768 " Allocating a socket buffer to interface %s failed\n",
1da177e4
LT		 1769 card->dev->name);
1770 card->stats.rx_dropped++;
1771 return;
1772 }
59ae1d12 1773 skb_put_data(skb, skb_data, skb_len);
1da177e4
LT		 1774 skb->protocol = card->lan_type_trans(skb, card->dev);
1775 card->stats.rx_bytes += skb_len;
1776 card->stats.rx_packets++;
93ad37d9
KW		 1777 if (skb->protocol == htons(ETH_P_802_2))
1778 *((__u32 *)skb->cb) = ++card->pkt_seq;
1da177e4
LT		 1779 netif_rx(skb);
1780}
1781
239686c1 1782/*
1da177e4
LT		 1783 * LCS main routine to get packets and lancmd replies from the buffers
1784 */
1785static void
1786lcs_get_frames_cb(struct lcs_channel *channel, struct lcs_buffer *buffer)
1787{
1788 struct lcs_card *card;
1789 struct lcs_header *lcs_hdr;
1790 __u16 offset;
1791
1792 LCS_DBF_TEXT(5, trace, "lcsgtpkt");
1793 lcs_hdr = (struct lcs_header *) buffer->data;
1794 if (lcs_hdr->offset == LCS_ILLEGAL_OFFSET) {
1795 LCS_DBF_TEXT(4, trace, "-eiogpkt");
1796 return;
1797 }
b385a144 1798 card = container_of(channel, struct lcs_card, read);
1da177e4
LT		 1799 offset = 0;
1800 while (lcs_hdr->offset != 0) {
1801 if (lcs_hdr->offset <= 0 ||
1802 lcs_hdr->offset > LCS_IOBUFFERSIZE ||
1803 lcs_hdr->offset < offset) {
1804 /* Offset invalid. */
1805 card->stats.rx_length_errors++;
1806 card->stats.rx_errors++;
1807 return;
1808 }
1809 /* What kind of frame is it? */
09ae5982 1810 if (lcs_hdr->type == LCS_FRAME_TYPE_CONTROL) {
1da177e4
LT		 1811 /* Control frame. */
1812 lcs_get_control(card, (struct lcs_cmd *) lcs_hdr);
09ae5982
HC		 1813 } else if (lcs_hdr->type == LCS_FRAME_TYPE_ENET ||
1814 lcs_hdr->type == LCS_FRAME_TYPE_TR ||
1815 lcs_hdr->type == LCS_FRAME_TYPE_FDDI) {
1da177e4
LT		 1816 /* Normal network packet. */
1817 lcs_get_skb(card, (char *)(lcs_hdr + 1),
1818 lcs_hdr->offset - offset -
1819 sizeof(struct lcs_header));
09ae5982 1820 } else {
1da177e4
LT		 1821 /* Unknown frame type. */
1822 ; // FIXME: error message ?
09ae5982 1823 }
1da177e4
LT		 1824 /* Proceed to next frame. */
1825 offset = lcs_hdr->offset;
1826 lcs_hdr->offset = LCS_ILLEGAL_OFFSET;
1827 lcs_hdr = (struct lcs_header *) (buffer->data + offset);
1828 }
1829 /* The buffer is now empty. Make it ready again. */
1830 lcs_ready_buffer(&card->read, buffer);
1831}
1832
239686c1 1833/*
1da177e4
LT		 1834 * get network statistics for ifconfig and other user programs
1835 */
1836static struct net_device_stats *
1837lcs_getstats(struct net_device *dev)
1838{
1839 struct lcs_card *card;
1840
1841 LCS_DBF_TEXT(4, trace, "netstats");
ad660e2f 1842 card = (struct lcs_card *) dev->ml_priv;
1da177e4
LT		 1843 return &card->stats;
1844}
1845
239686c1 1846/*
1da177e4
LT		 1847 * stop lcs device
1848 * This function will be called by user doing ifconfig xxx down
1849 */
1850static int
1851lcs_stop_device(struct net_device *dev)
1852{
1853 struct lcs_card *card;
1854 int rc;
1855
1856 LCS_DBF_TEXT(2, trace, "stopdev");
ad660e2f 1857 card = (struct lcs_card *) dev->ml_priv;
27eb5ac8
KW		 1858 netif_carrier_off(dev);
1859 netif_tx_disable(dev);
1da177e4 1860 dev->flags &= ~IFF_UP;
27eb5ac8 1861 wait_event(card->write.wait_q,
9163bb2e 1862 (card->write.state != LCS_CH_STATE_RUNNING));
1da177e4
LT		 1863 rc = lcs_stopcard(card);
1864 if (rc)
c99fc5da 1865 dev_err(&card->dev->dev,
f7e3a16c 1866 " Shutting down the LCS device failed\n");
1da177e4
LT		 1867 return rc;
1868}
1869
239686c1 1870/*
1da177e4
LT		 1871 * start lcs device and make it runnable
1872 * This function will be called by user doing ifconfig xxx up
1873 */
1874static int
1875lcs_open_device(struct net_device *dev)
1876{
1877 struct lcs_card *card;
1878 int rc;
1879
1880 LCS_DBF_TEXT(2, trace, "opendev");
ad660e2f 1881 card = (struct lcs_card *) dev->ml_priv;
1da177e4
LT		 1882 /* initialize statistics */
1883 rc = lcs_detect(card);
1884 if (rc) {
c99fc5da 1885 pr_err("Error in opening device!\n");
1da177e4
LT		 1886
1887 } else {
1888 dev->flags |= IFF_UP;
27eb5ac8 1889 netif_carrier_on(dev);
1da177e4
LT		 1890 netif_wake_queue(dev);
1891 card->state = DEV_STATE_UP;
1892 }
1893 return rc;
1894}
1895
239686c1 1896/*
1da177e4
LT		 1897 * show function for portno called by cat or similar things
1898 */
1899static ssize_t
3fd3c0a5 1900lcs_portno_show (struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1901{
1902 struct lcs_card *card;
1903
dff59b64 1904 card = dev_get_drvdata(dev);
1da177e4
LT		 1905
1906 if (!card)
1907 return 0;
1908
1909 return sprintf(buf, "%d\n", card->portno);
1910}
1911
239686c1 1912/*
1da177e4
LT		 1913 * store the value which is piped to file portno
1914 */
1915static ssize_t
3fd3c0a5 1916lcs_portno_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1917{
1918 struct lcs_card *card;
786f0065
TR		 1919 int rc;
1920 s16 value;
1da177e4 1921
dff59b64 1922 card = dev_get_drvdata(dev);
1da177e4
LT		 1923
1924 if (!card)
1925 return 0;
1926
786f0065
TR		 1927 rc = kstrtos16(buf, 0, &value);
1928 if (rc)
a68be015 1929 return -EINVAL;
1da177e4
LT		 1930 /* TODO: sanity checks */
1931 card->portno = value;
71c46897
UB		 1932 if (card->dev)
1933 card->dev->dev_port = card->portno;
1da177e4
LT		 1934
1935 return count;
1936
1937}
1938
1939static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
1940
c4736d96 1941static const char *lcs_type[] = {
0ca8cc6f
UB		 1942 "not a channel",
1943 "2216 parallel",
1944 "2216 channel",
1945 "OSA LCS card",
1946 "unknown channel type",
1947 "unsupported channel type",
1948};
1949
1da177e4 1950static ssize_t
3fd3c0a5 1951lcs_type_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1952{
1953 struct ccwgroup_device *cgdev;
1954
1955 cgdev = to_ccwgroupdev(dev);
1956 if (!cgdev)
1957 return -ENODEV;
1958
0ca8cc6f 1959 return sprintf(buf, "%s\n", lcs_type[cgdev->cdev[0]->id.driver_info]);
1da177e4
LT		 1960}
1961
1962static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
1963
1964static ssize_t
3fd3c0a5 1965lcs_timeout_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 1966{
1967 struct lcs_card *card;
1968
dff59b64 1969 card = dev_get_drvdata(dev);
1da177e4
LT		 1970
1971 return card ? sprintf(buf, "%u\n", card->lancmd_timeout) : 0;
1972}
1973
1974static ssize_t
3fd3c0a5 1975lcs_timeout_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 1976{
1977 struct lcs_card *card;
a68be015
UB		 1978 unsigned int value;
1979 int rc;
1da177e4 1980
dff59b64 1981 card = dev_get_drvdata(dev);
1da177e4
LT		 1982
1983 if (!card)
1984 return 0;
1985
786f0065
TR		 1986 rc = kstrtouint(buf, 0, &value);
1987 if (rc)
a68be015 1988 return -EINVAL;
1da177e4
LT		 1989 /* TODO: sanity checks */
1990 card->lancmd_timeout = value;
1991
1992 return count;
1993
1994}
1995
2b67fc46 1996static DEVICE_ATTR(lancmd_timeout, 0644, lcs_timeout_show, lcs_timeout_store);
1da177e4 1997
27eb5ac8 1998static ssize_t
e82b0f2c 1999lcs_dev_recover_store(struct device *dev, struct device_attribute *attr,
27eb5ac8
KW		 2000 const char *buf, size_t count)
2001{
dff59b64 2002 struct lcs_card *card = dev_get_drvdata(dev);
27eb5ac8
KW		 2003 char *tmp;
2004 int i;
2005
2006 if (!card)
2007 return -EINVAL;
2008 if (card->state != DEV_STATE_UP)
2009 return -EPERM;
2010 i = simple_strtoul(buf, &tmp, 16);
2011 if (i == 1)
2012 lcs_schedule_recovery(card);
2013 return count;
2014}
2015
2016static DEVICE_ATTR(recover, 0200, NULL, lcs_dev_recover_store);
2017
1da177e4
LT		 2018static struct attribute * lcs_attrs[] = {
2019 &dev_attr_portno.attr,
2020 &dev_attr_type.attr,
2021 &dev_attr_lancmd_timeout.attr,
27eb5ac8 2022 &dev_attr_recover.attr,
1da177e4
LT		 2023 NULL,
2024};
1da177e4
LT		 2025static struct attribute_group lcs_attr_group = {
2026 .attrs = lcs_attrs,
2027};
00d5bdd1
SO		 2028static const struct attribute_group *lcs_attr_groups[] = {
2029 &lcs_attr_group,
2030 NULL,
2031};
2032static const struct device_type lcs_devtype = {
2033 .name = "lcs",
2034 .groups = lcs_attr_groups,
2035};
1da177e4 2036
239686c1 2037/*
1da177e4
LT		 2038 * lcs_probe_device is called on establishing a new ccwgroup_device.
2039 */
2040static int
2041lcs_probe_device(struct ccwgroup_device *ccwgdev)
2042{
2043 struct lcs_card *card;
1da177e4
LT		 2044
2045 if (!get_device(&ccwgdev->dev))
2046 return -ENODEV;
2047
2048 LCS_DBF_TEXT(2, setup, "add_dev");
2049 card = lcs_alloc_card();
2050 if (!card) {
6b648063 2051 LCS_DBF_TEXT_(2, setup, " rc%d", -ENOMEM);
1da177e4
LT		 2052 put_device(&ccwgdev->dev);
2053 return -ENOMEM;
2054 }
dff59b64 2055 dev_set_drvdata(&ccwgdev->dev, card);
1da177e4
LT		 2056 ccwgdev->cdev[0]->handler = lcs_irq;
2057 ccwgdev->cdev[1]->handler = lcs_irq;
27eb5ac8 2058 card->gdev = ccwgdev;
4927b3f7 2059 INIT_WORK(&card->kernel_thread_starter, lcs_start_kernel_thread);
27eb5ac8
KW		 2060 card->thread_start_mask = 0;
2061 card->thread_allowed_mask = 0;
2062 card->thread_running_mask = 0;
00d5bdd1
SO		 2063 ccwgdev->dev.type = &lcs_devtype;
2064
2065 return 0;
1da177e4
LT		 2066}
2067
2068static int
2069lcs_register_netdev(struct ccwgroup_device *ccwgdev)
2070{
2071 struct lcs_card *card;
2072
2073 LCS_DBF_TEXT(2, setup, "regnetdv");
dff59b64 2074 card = dev_get_drvdata(&ccwgdev->dev);
1da177e4
LT		 2075 if (card->dev->reg_state != NETREG_UNINITIALIZED)
2076 return 0;
2077 SET_NETDEV_DEV(card->dev, &ccwgdev->dev);
2078 return register_netdev(card->dev);
2079}
2080
239686c1 2081/*
1da177e4
LT		 2082 * lcs_new_device will be called by setting the group device online.
2083 */
0e0b46d8
FB		 2084static const struct net_device_ops lcs_netdev_ops = {
2085 .ndo_open = lcs_open_device,
2086 .ndo_stop = lcs_stop_device,
2087 .ndo_get_stats = lcs_getstats,
2088 .ndo_start_xmit = lcs_start_xmit,
2089};
2090
2091static const struct net_device_ops lcs_mc_netdev_ops = {
2092 .ndo_open = lcs_open_device,
2093 .ndo_stop = lcs_stop_device,
2094 .ndo_get_stats = lcs_getstats,
2095 .ndo_start_xmit = lcs_start_xmit,
afc4b13d 2096 .ndo_set_rx_mode = lcs_set_multicast_list,
0e0b46d8 2097};
1da177e4
LT		 2098
2099static int
2100lcs_new_device(struct ccwgroup_device *ccwgdev)
2101{
2102 struct lcs_card *card;
2103 struct net_device *dev=NULL;
2104 enum lcs_dev_states recover_state;
2105 int rc;
2106
dff59b64 2107 card = dev_get_drvdata(&ccwgdev->dev);
1da177e4
LT		 2108 if (!card)
2109 return -ENODEV;
2110
2111 LCS_DBF_TEXT(2, setup, "newdev");
2112 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2113 card->read.ccwdev = ccwgdev->cdev[0];
2114 card->write.ccwdev = ccwgdev->cdev[1];
2115
2116 recover_state = card->state;
d816d423
KDW		 2117 rc = ccw_device_set_online(card->read.ccwdev);
2118 if (rc)
2119 goto out_err;
2120 rc = ccw_device_set_online(card->write.ccwdev);
2121 if (rc)
2122 goto out_werr;
1da177e4
LT		 2123
2124 LCS_DBF_TEXT(3, setup, "lcsnewdv");
2125
2126 lcs_setup_card(card);
2127 rc = lcs_detect(card);
2128 if (rc) {
2129 LCS_DBF_TEXT(2, setup, "dtctfail");
89a2a8e7 2130 dev_err(&ccwgdev->dev,
c99fc5da
KW		 2131 "Detecting a network adapter for LCS devices"
2132 " failed with rc=%d (0x%x)\n", rc, rc);
1da177e4
LT		 2133 lcs_stopcard(card);
2134 goto out;
2135 }
2136 if (card->dev) {
2137 LCS_DBF_TEXT(2, setup, "samedev");
2138 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2139 goto netdev_out;
2140 }
2141 switch (card->lan_type) {
1e495701 2142#ifdef CONFIG_ETHERNET
1da177e4
LT		 2143 case LCS_FRAME_TYPE_ENET:
2144 card->lan_type_trans = eth_type_trans;
2145 dev = alloc_etherdev(0);
2146 break;
2147#endif
1da177e4
LT		 2148#ifdef CONFIG_FDDI
2149 case LCS_FRAME_TYPE_FDDI:
2150 card->lan_type_trans = fddi_type_trans;
2151 dev = alloc_fddidev(0);
2152 break;
2153#endif
2154 default:
2155 LCS_DBF_TEXT(3, setup, "errinit");
c99fc5da 2156 pr_err(" Initialization failed\n");
1da177e4
LT		 2157 goto out;
2158 }
2159 if (!dev)
2160 goto out;
2161 card->dev = dev;
ad660e2f 2162 card->dev->ml_priv = card;
0e0b46d8 2163 card->dev->netdev_ops = &lcs_netdev_ops;
71c46897 2164 card->dev->dev_port = card->portno;
978bb0ae 2165 eth_hw_addr_set(card->dev, card->mac);
1da177e4
LT		 2166#ifdef CONFIG_IP_MULTICAST
2167 if (!lcs_check_multicast_support(card))
0e0b46d8 2168 card->dev->netdev_ops = &lcs_mc_netdev_ops;
1da177e4 2169#endif
b5f9d55b 2170netdev_out:
1da177e4
LT		 2171 lcs_set_allowed_threads(card,0xffffffff);
2172 if (recover_state == DEV_STATE_RECOVER) {
2173 lcs_set_multicast_list(card->dev);
2174 card->dev->flags |= IFF_UP;
27eb5ac8 2175 netif_carrier_on(card->dev);
1da177e4
LT		 2176 netif_wake_queue(card->dev);
2177 card->state = DEV_STATE_UP;
b5f9d55b 2178 } else {
1da177e4 2179 lcs_stopcard(card);
b5f9d55b 2180 }
1da177e4 2181
b5f9d55b
FP		 2182 if (lcs_register_netdev(ccwgdev) != 0)
2183 goto out;
2184
2185 /* Print out supported assists: IPv6 */
c99fc5da
KW		 2186 pr_info("LCS device %s %s IPv6 support\n", card->dev->name,
2187 (card->ip_assists_supported & LCS_IPASS_IPV6_SUPPORT) ?
2188 "with" : "without");
b5f9d55b 2189 /* Print out supported assist: Multicast */
c99fc5da
KW		 2190 pr_info("LCS device %s %s Multicast support\n", card->dev->name,
2191 (card->ip_assists_supported & LCS_IPASS_MULTICAST_SUPPORT) ?
2192 "with" : "without");
1da177e4
LT		 2193 return 0;
2194out:
2195
1da177e4 2196 ccw_device_set_offline(card->write.ccwdev);
d816d423
KDW		 2197out_werr:
2198 ccw_device_set_offline(card->read.ccwdev);
2199out_err:
1da177e4
LT		 2200 return -ENODEV;
2201}
2202
239686c1 2203/*
1da177e4
LT		 2204 * lcs_shutdown_device, called when setting the group device offline.
2205 */
2206static int
27eb5ac8 2207__lcs_shutdown_device(struct ccwgroup_device *ccwgdev, int recovery_mode)
1da177e4
LT		 2208{
2209 struct lcs_card *card;
2210 enum lcs_dev_states recover_state;
e427babe 2211 int ret = 0, ret2 = 0, ret3 = 0;
1da177e4
LT		 2212
2213 LCS_DBF_TEXT(3, setup, "shtdndev");
dff59b64 2214 card = dev_get_drvdata(&ccwgdev->dev);
1da177e4
LT		 2215 if (!card)
2216 return -ENODEV;
27eb5ac8
KW		 2217 if (recovery_mode == 0) {
2218 lcs_set_allowed_threads(card, 0);
2219 if (lcs_wait_for_threads(card, LCS_SET_MC_THREAD))
2220 return -ERESTARTSYS;
2221 }
1da177e4
LT		 2222 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2223 recover_state = card->state;
2224
2225 ret = lcs_stop_device(card->dev);
e427babe
KDW		 2226 ret2 = ccw_device_set_offline(card->read.ccwdev);
2227 ret3 = ccw_device_set_offline(card->write.ccwdev);
2228 if (!ret)
2229 ret = (ret2) ? ret2 : ret3;
2230 if (ret)
2231 LCS_DBF_TEXT_(3, setup, "1err:%d", ret);
1da177e4
LT		 2232 if (recover_state == DEV_STATE_UP) {
2233 card->state = DEV_STATE_RECOVER;
2234 }
1da177e4
LT		 2235 return 0;
2236}
2237
27eb5ac8
KW		 2238static int
2239lcs_shutdown_device(struct ccwgroup_device *ccwgdev)
2240{
2241 return __lcs_shutdown_device(ccwgdev, 0);
2242}
2243
239686c1 2244/*
27eb5ac8
KW		 2245 * drive lcs recovery after startup and startlan initiated by Lan Gateway
2246 */
2247static int
2248lcs_recovery(void *ptr)
2249{
2250 struct lcs_card *card;
2251 struct ccwgroup_device *gdev;
2252 int rc;
2253
2254 card = (struct lcs_card *) ptr;
27eb5ac8
KW		 2255
2256 LCS_DBF_TEXT(4, trace, "recover1");
2257 if (!lcs_do_run_thread(card, LCS_RECOVERY_THREAD))
2258 return 0;
2259 LCS_DBF_TEXT(4, trace, "recover2");
2260 gdev = card->gdev;
c99fc5da
KW		 2261 dev_warn(&gdev->dev,
2262 "A recovery process has been started for the LCS device\n");
27eb5ac8
KW		 2263 rc = __lcs_shutdown_device(gdev, 1);
2264 rc = lcs_new_device(gdev);
2265 if (!rc)
c99fc5da
KW		 2266 pr_info("Device %s successfully recovered!\n",
2267 card->dev->name);
27eb5ac8 2268 else
c99fc5da
KW		 2269 pr_info("Device %s could not be recovered!\n",
2270 card->dev->name);
27eb5ac8
KW		 2271 lcs_clear_thread_running_bit(card, LCS_RECOVERY_THREAD);
2272 return 0;
2273}
2274
239686c1 2275/*
1da177e4
LT		 2276 * lcs_remove_device, free buffers and card
2277 */
2278static void
2279lcs_remove_device(struct ccwgroup_device *ccwgdev)
2280{
2281 struct lcs_card *card;
2282
dff59b64 2283 card = dev_get_drvdata(&ccwgdev->dev);
1da177e4
LT		 2284 if (!card)
2285 return;
2286
1da177e4
LT		 2287 LCS_DBF_TEXT(3, setup, "remdev");
2288 LCS_DBF_HEX(3, setup, &card, sizeof(void*));
2289 if (ccwgdev->state == CCWGROUP_ONLINE) {
2290 lcs_shutdown_device(ccwgdev);
2291 }
2292 if (card->dev)
2293 unregister_netdev(card->dev);
1da177e4
LT		 2294 lcs_cleanup_card(card);
2295 lcs_free_card(card);
00d5bdd1 2296 dev_set_drvdata(&ccwgdev->dev, NULL);
1da177e4
LT		 2297 put_device(&ccwgdev->dev);
2298}
2299
0ca8cc6f
UB		 2300static struct ccw_device_id lcs_ids[] = {
2301 {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},
2302 {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
2303 {CCW_DEVICE(0x3088, 0x60), .driver_info = lcs_channel_type_osa2},
2304 {},
2305};
2306MODULE_DEVICE_TABLE(ccw, lcs_ids);
2307
2308static struct ccw_driver lcs_ccw_driver = {
3bda058b
SO		 2309 .driver = {
2310 .owner = THIS_MODULE,
2311 .name = "lcs",
2312 },
0ca8cc6f
UB		 2313 .ids = lcs_ids,
2314 .probe = ccwgroup_probe_ccwdev,
2315 .remove = ccwgroup_remove_ccwdev,
420f42ec 2316 .int_class = IRQIO_LCS,
0ca8cc6f
UB		 2317};
2318
239686c1 2319/*
1da177e4
LT		 2320 * LCS ccwgroup driver registration
2321 */
2322static struct ccwgroup_driver lcs_group_driver = {
3c190c51
SO		 2323 .driver = {
2324 .owner = THIS_MODULE,
2325 .name = "lcs",
2326 },
f9a5d70c 2327 .ccw_driver = &lcs_ccw_driver,
00d5bdd1 2328 .setup = lcs_probe_device,
1da177e4
LT		 2329 .remove = lcs_remove_device,
2330 .set_online = lcs_new_device,
2331 .set_offline = lcs_shutdown_device,
2332};
2333
36369569
GKH		 2334static ssize_t group_store(struct device_driver *ddrv, const char *buf,
2335 size_t count)
0ca8cc6f
UB		 2336{
2337 int err;
9814fdfb 2338 err = ccwgroup_create_dev(lcs_root_dev, &lcs_group_driver, 2, buf);
0ca8cc6f
UB		 2339 return err ? err : count;
2340}
36369569 2341static DRIVER_ATTR_WO(group);
0ca8cc6f 2342
9d2aa0aa 2343static struct attribute *lcs_drv_attrs[] = {
0ca8cc6f
UB		 2344 &driver_attr_group.attr,
2345 NULL,
2346};
9d2aa0aa
SO		 2347static struct attribute_group lcs_drv_attr_group = {
2348 .attrs = lcs_drv_attrs,
0ca8cc6f 2349};
9d2aa0aa
SO		 2350static const struct attribute_group *lcs_drv_attr_groups[] = {
2351 &lcs_drv_attr_group,
0ca8cc6f
UB		 2352 NULL,
2353};
2354
239686c1 2355/*
1da177e4
LT		 2356 * LCS Module/Kernel initialization function
2357 */
2358static int
2359__init lcs_init_module(void)
2360{
2361 int rc;
2362
c99fc5da 2363 pr_info("Loading %s\n", version);
1da177e4
LT		 2364 rc = lcs_register_debug_facility();
2365 LCS_DBF_TEXT(0, setup, "lcsinit");
0ca8cc6f
UB		 2366 if (rc)
2367 goto out_err;
2368 lcs_root_dev = root_device_register("lcs");
6274edc5 2369 rc = PTR_ERR_OR_ZERO(lcs_root_dev);
0ca8cc6f
UB		 2370 if (rc)
2371 goto register_err;
2372 rc = ccw_driver_register(&lcs_ccw_driver);
2373 if (rc)
2374 goto ccw_err;
9d2aa0aa 2375 lcs_group_driver.driver.groups = lcs_drv_attr_groups;
0ca8cc6f
UB		 2376 rc = ccwgroup_driver_register(&lcs_group_driver);
2377 if (rc)
2378 goto ccwgroup_err;
1da177e4 2379 return 0;
0ca8cc6f
UB		 2380
2381ccwgroup_err:
2382 ccw_driver_unregister(&lcs_ccw_driver);
2383ccw_err:
2384 root_device_unregister(lcs_root_dev);
2385register_err:
2386 lcs_unregister_debug_facility();
2387out_err:
2388 pr_err("Initializing the lcs device driver failed\n");
2389 return rc;
1da177e4
LT		 2390}
2391
2392
239686c1 2393/*
1da177e4
LT		 2394 * LCS module cleanup function
2395 */
2396static void
2397__exit lcs_cleanup_module(void)
2398{
c99fc5da 2399 pr_info("Terminating lcs module.\n");
1da177e4 2400 LCS_DBF_TEXT(0, trace, "cleanup");
0ca8cc6f
UB		 2401 ccwgroup_driver_unregister(&lcs_group_driver);
2402 ccw_driver_unregister(&lcs_ccw_driver);
2403 root_device_unregister(lcs_root_dev);
1da177e4
LT		 2404 lcs_unregister_debug_facility();
2405}
2406
2407module_init(lcs_init_module);
2408module_exit(lcs_cleanup_module);
2409
1387780f 2410MODULE_AUTHOR("Frank Pavlic <fpavlic@de.ibm.com>");
1da177e4
LT		 2411MODULE_LICENSE("GPL");
2412
Linux 6.x block layer and io_uring tree(s)