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