write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/char/lp.c
..
..
@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * Generic parallel printer driver
3
4
  *
..
..
@@ -46,8 +47,8 @@
46
47
  *	lp=auto				(assign lp devices to all ports that
47
48
  *				         have printers attached, as determined
48
49
  *					 by the IEEE-1284 autoprobe)
49
- * 
50
- *	lp=reset			(reset the printer during 
50
+ *
51
+ *	lp=reset			(reset the printer during
51
52
  *					 initialisation)
52
53
  *
53
54
  *	lp=off				(disable the printer driver entirely)
..
..
@@ -141,6 +142,7 @@
141
142
 
142
143
 static DEFINE_MUTEX(lp_mutex);
143
144
 static struct lp_struct lp_table[LP_NO];
145
+static int port_num[LP_NO];
144
146
 
145
147
 static unsigned int lp_count = 0;
146
148
 static struct class *lp_class;
..
..
@@ -166,7 +168,7 @@
166
168
 static void lp_claim_parport_or_block(struct lp_struct *this_lp)
167
169
 {
168
170
 	if (!test_and_set_bit(LP_PARPORT_CLAIMED, &this_lp->bits)) {
169
-		parport_claim_or_block (this_lp->dev);
171
+		parport_claim_or_block(this_lp->dev);
170
172
 	}
171
173
 }
172
174
 
..
..
@@ -174,7 +176,7 @@
174
176
 static void lp_release_parport(struct lp_struct *this_lp)
175
177
 {
176
178
 	if (test_and_clear_bit(LP_PARPORT_CLAIMED, &this_lp->bits)) {
177
-		parport_release (this_lp->dev);
179
+		parport_release(this_lp->dev);
178
180
 	}
179
181
 }
180
182
 
..
..
@@ -184,37 +186,37 @@
184
186
 {
185
187
 	struct lp_struct *this_lp = (struct lp_struct *)handle;
186
188
 	set_bit(LP_PREEMPT_REQUEST, &this_lp->bits);
187
-	return (1);
189
+	return 1;
188
190
 }
189
191
 
190
192
 
191
-/* 
193
+/*
192
194
  * Try to negotiate to a new mode; if unsuccessful negotiate to
193
195
  * compatibility mode.  Return the mode we ended up in.
194
196
  */
195
-static int lp_negotiate(struct parport * port, int mode)
197
+static int lp_negotiate(struct parport *port, int mode)
196
198
 {
197
-	if (parport_negotiate (port, mode) != 0) {
199
+	if (parport_negotiate(port, mode) != 0) {
198
200
 		mode = IEEE1284_MODE_COMPAT;
199
-		parport_negotiate (port, mode);
201
+		parport_negotiate(port, mode);
200
202
 	}
201
203
 
202
-	return (mode);
204
+	return mode;
203
205
 }
204
206
 
205
207
 static int lp_reset(int minor)
206
208
 {
207
209
 	int retval;
208
-	lp_claim_parport_or_block (&lp_table[minor]);
210
+	lp_claim_parport_or_block(&lp_table[minor]);
209
211
 	w_ctr(minor, LP_PSELECP);
210
-	udelay (LP_DELAY);
212
+	udelay(LP_DELAY);
211
213
 	w_ctr(minor, LP_PSELECP | LP_PINITP);
212
214
 	retval = r_str(minor);
213
-	lp_release_parport (&lp_table[minor]);
215
+	lp_release_parport(&lp_table[minor]);
214
216
 	return retval;
215
217
 }
216
218
 
217
-static void lp_error (int minor)
219
+static void lp_error(int minor)
218
220
 {
219
221
 	DEFINE_WAIT(wait);
220
222
 	int polling;
..
..
@@ -223,12 +225,15 @@
223
225
 		return;
224
226
 
225
227
 	polling = lp_table[minor].dev->port->irq == PARPORT_IRQ_NONE;
226
-	if (polling) lp_release_parport (&lp_table[minor]);
228
+	if (polling)
229
+		lp_release_parport(&lp_table[minor]);
227
230
 	prepare_to_wait(&lp_table[minor].waitq, &wait, TASK_INTERRUPTIBLE);
228
231
 	schedule_timeout(LP_TIMEOUT_POLLED);
229
232
 	finish_wait(&lp_table[minor].waitq, &wait);
230
-	if (polling) lp_claim_parport_or_block (&lp_table[minor]);
231
-	else parport_yield_blocking (lp_table[minor].dev);
233
+	if (polling)
234
+		lp_claim_parport_or_block(&lp_table[minor]);
235
+	else
236
+		parport_yield_blocking(lp_table[minor].dev);
232
237
 }
233
238
 
234
239
 static int lp_check_status(int minor)
..
..
@@ -259,7 +264,7 @@
259
264
 		error = -EIO;
260
265
 	} else {
261
266
 		last = 0; /* Come here if LP_CAREFUL is set and no
262
-                             errors are reported. */
267
+			     errors are reported. */
263
268
 	}
264
269
 
265
270
 	lp_table[minor].last_error = last;
..
..
@@ -276,14 +281,14 @@
276
281
 
277
282
 	/* If we're not in compatibility mode, we're ready now! */
278
283
 	if (lp_table[minor].current_mode != IEEE1284_MODE_COMPAT) {
279
-	  return (0);
284
+		return 0;
280
285
 	}
281
286
 
282
287
 	do {
283
-		error = lp_check_status (minor);
288
+		error = lp_check_status(minor);
284
289
 		if (error && (nonblock || (LP_F(minor) & LP_ABORT)))
285
290
 			break;
286
-		if (signal_pending (current)) {
291
+		if (signal_pending(current)) {
287
292
 			error = -EINTR;
288
293
 			break;
289
294
 		}
..
..
@@ -291,8 +296,8 @@
291
296
 	return error;
292
297
 }
293
298
 
294
-static ssize_t lp_write(struct file * file, const char __user * buf,
295
-		        size_t count, loff_t *ppos)
299
+static ssize_t lp_write(struct file *file, const char __user *buf,
300
+			size_t count, loff_t *ppos)
296
301
 {
297
302
 	unsigned int minor = iminor(file_inode(file));
298
303
 	struct parport *port = lp_table[minor].dev->port;
..
..
@@ -317,26 +322,26 @@
317
322
 	if (mutex_lock_interruptible(&lp_table[minor].port_mutex))
318
323
 		return -EINTR;
319
324
 
320
-	if (copy_from_user (kbuf, buf, copy_size)) {
325
+	if (copy_from_user(kbuf, buf, copy_size)) {
321
326
 		retv = -EFAULT;
322
327
 		goto out_unlock;
323
328
 	}
324
329
 
325
- 	/* Claim Parport or sleep until it becomes available
326
- 	 */
327
-	lp_claim_parport_or_block (&lp_table[minor]);
330
+	/* Claim Parport or sleep until it becomes available
331
+	 */
332
+	lp_claim_parport_or_block(&lp_table[minor]);
328
333
 	/* Go to the proper mode. */
329
-	lp_table[minor].current_mode = lp_negotiate (port, 
330
-						     lp_table[minor].best_mode);
334
+	lp_table[minor].current_mode = lp_negotiate(port,
335
+						    lp_table[minor].best_mode);
331
336
 
332
-	parport_set_timeout (lp_table[minor].dev,
333
-			     (nonblock ? PARPORT_INACTIVITY_O_NONBLOCK
334
-			      : lp_table[minor].timeout));
337
+	parport_set_timeout(lp_table[minor].dev,
338
+			    (nonblock ? PARPORT_INACTIVITY_O_NONBLOCK
339
+			     : lp_table[minor].timeout));
335
340
 
336
-	if ((retv = lp_wait_ready (minor, nonblock)) == 0)
341
+	if ((retv = lp_wait_ready(minor, nonblock)) == 0)
337
342
 	do {
338
343
 		/* Write the data. */
339
-		written = parport_write (port, kbuf, copy_size);
344
+		written = parport_write(port, kbuf, copy_size);
340
345
 		if (written > 0) {
341
346
 			copy_size -= written;
342
347
 			count -= written;
..
..
@@ -344,7 +349,7 @@
344
349
 			retv += written;
345
350
 		}
346
351
 
347
-		if (signal_pending (current)) {
352
+		if (signal_pending(current)) {
348
353
 			if (retv == 0)
349
354
 				retv = -EINTR;
350
355
 
..
..
@@ -355,11 +360,11 @@
355
360
 			/* incomplete write -> check error ! */
356
361
 			int error;
357
362
 
358
-			parport_negotiate (lp_table[minor].dev->port, 
359
-					   IEEE1284_MODE_COMPAT);
363
+			parport_negotiate(lp_table[minor].dev->port,
364
+					  IEEE1284_MODE_COMPAT);
360
365
 			lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
361
366
 
362
-			error = lp_wait_ready (minor, nonblock);
367
+			error = lp_wait_ready(minor, nonblock);
363
368
 
364
369
 			if (error) {
365
370
 				if (retv == 0)
..
..
@@ -371,13 +376,13 @@
371
376
 				break;
372
377
 			}
373
378
 
374
-			parport_yield_blocking (lp_table[minor].dev);
375
-			lp_table[minor].current_mode 
376
-			  = lp_negotiate (port, 
377
-					  lp_table[minor].best_mode);
379
+			parport_yield_blocking(lp_table[minor].dev);
380
+			lp_table[minor].current_mode
381
+			  = lp_negotiate(port,
382
+					 lp_table[minor].best_mode);
378
383
 
379
384
 		} else if (need_resched())
380
-			schedule ();
385
+			schedule();
381
386
 
382
387
 		if (count) {
383
388
 			copy_size = count;
..
..
@@ -389,27 +394,27 @@
389
394
 					retv = -EFAULT;
390
395
 				break;
391
396
 			}
392
-		}	
397
+		}
393
398
 	} while (count > 0);
394
399
 
395
-	if (test_and_clear_bit(LP_PREEMPT_REQUEST, 
400
+	if (test_and_clear_bit(LP_PREEMPT_REQUEST,
396
401
 			       &lp_table[minor].bits)) {
397
402
 		printk(KERN_INFO "lp%d releasing parport\n", minor);
398
-		parport_negotiate (lp_table[minor].dev->port, 
399
-				   IEEE1284_MODE_COMPAT);
403
+		parport_negotiate(lp_table[minor].dev->port,
404
+				  IEEE1284_MODE_COMPAT);
400
405
 		lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
401
-		lp_release_parport (&lp_table[minor]);
406
+		lp_release_parport(&lp_table[minor]);
402
407
 	}
403
408
 out_unlock:
404
409
 	mutex_unlock(&lp_table[minor].port_mutex);
405
410
 
406
- 	return retv;
411
+	return retv;
407
412
 }
408
413
 
409
414
 #ifdef CONFIG_PARPORT_1284
410
415
 
411
416
 /* Status readback conforming to ieee1284 */
412
-static ssize_t lp_read(struct file * file, char __user * buf,
417
+static ssize_t lp_read(struct file *file, char __user *buf,
413
418
 		       size_t count, loff_t *ppos)
414
419
 {
415
420
 	DEFINE_WAIT(wait);
..
..
@@ -426,21 +431,21 @@
426
431
 	if (mutex_lock_interruptible(&lp_table[minor].port_mutex))
427
432
 		return -EINTR;
428
433
 
429
-	lp_claim_parport_or_block (&lp_table[minor]);
434
+	lp_claim_parport_or_block(&lp_table[minor]);
430
435
 
431
-	parport_set_timeout (lp_table[minor].dev,
432
-			     (nonblock ? PARPORT_INACTIVITY_O_NONBLOCK
433
-			      : lp_table[minor].timeout));
436
+	parport_set_timeout(lp_table[minor].dev,
437
+			    (nonblock ? PARPORT_INACTIVITY_O_NONBLOCK
438
+			     : lp_table[minor].timeout));
434
439
 
435
-	parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
436
-	if (parport_negotiate (lp_table[minor].dev->port,
437
-			       IEEE1284_MODE_NIBBLE)) {
440
+	parport_negotiate(lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
441
+	if (parport_negotiate(lp_table[minor].dev->port,
442
+			      IEEE1284_MODE_NIBBLE)) {
438
443
 		retval = -EIO;
439
444
 		goto out;
440
445
 	}
441
446
 
442
447
 	while (retval == 0) {
443
-		retval = parport_read (port, kbuf, count);
448
+		retval = parport_read(port, kbuf, count);
444
449
 
445
450
 		if (retval > 0)
446
451
 			break;
..
..
@@ -453,11 +458,11 @@
453
458
 		/* Wait for data. */
454
459
 
455
460
 		if (lp_table[minor].dev->port->irq == PARPORT_IRQ_NONE) {
456
-			parport_negotiate (lp_table[minor].dev->port,
457
-					   IEEE1284_MODE_COMPAT);
458
-			lp_error (minor);
459
-			if (parport_negotiate (lp_table[minor].dev->port,
460
-					       IEEE1284_MODE_NIBBLE)) {
461
+			parport_negotiate(lp_table[minor].dev->port,
462
+					  IEEE1284_MODE_COMPAT);
463
+			lp_error(minor);
464
+			if (parport_negotiate(lp_table[minor].dev->port,
465
+					      IEEE1284_MODE_NIBBLE)) {
461
466
 				retval = -EIO;
462
467
 				goto out;
463
468
 			}
..
..
@@ -467,18 +472,18 @@
467
472
 			finish_wait(&lp_table[minor].waitq, &wait);
468
473
 		}
469
474
 
470
-		if (signal_pending (current)) {
475
+		if (signal_pending(current)) {
471
476
 			retval = -ERESTARTSYS;
472
477
 			break;
473
478
 		}
474
479
 
475
-		cond_resched ();
480
+		cond_resched();
476
481
 	}
477
-	parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
482
+	parport_negotiate(lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
478
483
  out:
479
-	lp_release_parport (&lp_table[minor]);
484
+	lp_release_parport(&lp_table[minor]);
480
485
 
481
-	if (retval > 0 && copy_to_user (buf, kbuf, retval))
486
+	if (retval > 0 && copy_to_user(buf, kbuf, retval))
482
487
 		retval = -EFAULT;
483
488
 
484
489
 	mutex_unlock(&lp_table[minor].port_mutex);
..
..
@@ -488,7 +493,7 @@
488
493
 
489
494
 #endif /* IEEE 1284 support */
490
495
 
491
-static int lp_open(struct inode * inode, struct file * file)
496
+static int lp_open(struct inode *inode, struct file *file)
492
497
 {
493
498
 	unsigned int minor = iminor(inode);
494
499
 	int ret = 0;
..
..
@@ -513,9 +518,9 @@
513
518
 	   should most likely only ever be used by the tunelp application. */
514
519
 	if ((LP_F(minor) & LP_ABORTOPEN) && !(file->f_flags & O_NONBLOCK)) {
515
520
 		int status;
516
-		lp_claim_parport_or_block (&lp_table[minor]);
521
+		lp_claim_parport_or_block(&lp_table[minor]);
517
522
 		status = r_str(minor);
518
-		lp_release_parport (&lp_table[minor]);
523
+		lp_release_parport(&lp_table[minor]);
519
524
 		if (status & LP_POUTPA) {
520
525
 			printk(KERN_INFO "lp%d out of paper\n", minor);
521
526
 			LP_F(minor) &= ~LP_BUSY;
..
..
@@ -540,32 +545,32 @@
540
545
 		goto out;
541
546
 	}
542
547
 	/* Determine if the peripheral supports ECP mode */
543
-	lp_claim_parport_or_block (&lp_table[minor]);
548
+	lp_claim_parport_or_block(&lp_table[minor]);
544
549
 	if ( (lp_table[minor].dev->port->modes & PARPORT_MODE_ECP) &&
545
-             !parport_negotiate (lp_table[minor].dev->port, 
546
-                                 IEEE1284_MODE_ECP)) {
547
-		printk (KERN_INFO "lp%d: ECP mode\n", minor);
550
+	     !parport_negotiate(lp_table[minor].dev->port,
551
+				 IEEE1284_MODE_ECP)) {
552
+		printk(KERN_INFO "lp%d: ECP mode\n", minor);
548
553
 		lp_table[minor].best_mode = IEEE1284_MODE_ECP;
549
554
 	} else {
550
555
 		lp_table[minor].best_mode = IEEE1284_MODE_COMPAT;
551
556
 	}
552
557
 	/* Leave peripheral in compatibility mode */
553
-	parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
554
-	lp_release_parport (&lp_table[minor]);
558
+	parport_negotiate(lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
559
+	lp_release_parport(&lp_table[minor]);
555
560
 	lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
556
561
 out:
557
562
 	mutex_unlock(&lp_mutex);
558
563
 	return ret;
559
564
 }
560
565
 
561
-static int lp_release(struct inode * inode, struct file * file)
566
+static int lp_release(struct inode *inode, struct file *file)
562
567
 {
563
568
 	unsigned int minor = iminor(inode);
564
569
 
565
-	lp_claim_parport_or_block (&lp_table[minor]);
566
-	parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
570
+	lp_claim_parport_or_block(&lp_table[minor]);
571
+	parport_negotiate(lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
567
572
 	lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
568
-	lp_release_parport (&lp_table[minor]);
573
+	lp_release_parport(&lp_table[minor]);
569
574
 	kfree(lp_table[minor].lp_buffer);
570
575
 	lp_table[minor].lp_buffer = NULL;
571
576
 	LP_F(minor) &= ~LP_BUSY;
..
..
@@ -615,7 +620,7 @@
615
620
 		case LPWAIT:
616
621
 			LP_WAIT(minor) = arg;
617
622
 			break;
618
-		case LPSETIRQ: 
623
+		case LPSETIRQ:
619
624
 			return -EINVAL;
620
625
 			break;
621
626
 		case LPGETIRQ:
..
..
@@ -626,9 +631,9 @@
626
631
 		case LPGETSTATUS:
627
632
 			if (mutex_lock_interruptible(&lp_table[minor].port_mutex))
628
633
 				return -EINTR;
629
-			lp_claim_parport_or_block (&lp_table[minor]);
634
+			lp_claim_parport_or_block(&lp_table[minor]);
630
635
 			status = r_str(minor);
631
-			lp_release_parport (&lp_table[minor]);
636
+			lp_release_parport(&lp_table[minor]);
632
637
 			mutex_unlock(&lp_table[minor].port_mutex);
633
638
 
634
639
 			if (copy_to_user(argp, &status, sizeof(int)))
..
..
@@ -647,8 +652,8 @@
647
652
 						sizeof(struct lp_stats));
648
653
 			break;
649
654
 #endif
650
- 		case LPGETFLAGS:
651
- 			status = LP_F(minor);
655
+		case LPGETFLAGS:
656
+			status = LP_F(minor);
652
657
 			if (copy_to_user(argp, &status, sizeof(int)))
653
658
 				return -EFAULT;
654
659
 			break;
..
..
@@ -729,7 +734,7 @@
729
734
 			ret = lp_set_timeout32(minor, (void __user *)arg);
730
735
 			break;
731
736
 		}
732
-		/* fallthrough for 64-bit */
737
+		fallthrough;	/* for 64-bit */
733
738
 	case LPSETTIMEOUT_NEW:
734
739
 		ret = lp_set_timeout64(minor, (void __user *)arg);
735
740
 		break;
..
..
@@ -757,7 +762,7 @@
757
762
 			ret = lp_set_timeout32(minor, (void __user *)arg);
758
763
 			break;
759
764
 		}
760
-		/* fallthrough for x32 mode */
765
+		fallthrough;	/* for x32 mode */
761
766
 	case LPSETTIMEOUT_NEW:
762
767
 		ret = lp_set_timeout64(minor, (void __user *)arg);
763
768
 		break;
..
..
@@ -805,31 +810,31 @@
805
810
 
806
811
 /* The console must be locked when we get here. */
807
812
 
808
-static void lp_console_write (struct console *co, const char *s,
809
-			      unsigned count)
813
+static void lp_console_write(struct console *co, const char *s,
814
+			     unsigned count)
810
815
 {
811
816
 	struct pardevice *dev = lp_table[CONSOLE_LP].dev;
812
817
 	struct parport *port = dev->port;
813
818
 	ssize_t written;
814
819
 
815
-	if (parport_claim (dev))
820
+	if (parport_claim(dev))
816
821
 		/* Nothing we can do. */
817
822
 		return;
818
823
 
819
-	parport_set_timeout (dev, 0);
824
+	parport_set_timeout(dev, 0);
820
825
 
821
826
 	/* Go to compatibility mode. */
822
-	parport_negotiate (port, IEEE1284_MODE_COMPAT);
827
+	parport_negotiate(port, IEEE1284_MODE_COMPAT);
823
828
 
824
829
 	do {
825
830
 		/* Write the data, converting LF->CRLF as we go. */
826
831
 		ssize_t canwrite = count;
827
-		char *lf = memchr (s, '\n', count);
832
+		char *lf = memchr(s, '\n', count);
828
833
 		if (lf)
829
834
 			canwrite = lf - s;
830
835
 
831
836
 		if (canwrite > 0) {
832
-			written = parport_write (port, s, canwrite);
837
+			written = parport_write(port, s, canwrite);
833
838
 
834
839
 			if (written <= 0)
835
840
 				continue;
..
..
@@ -847,14 +852,16 @@
847
852
 			s++;
848
853
 			count--;
849
854
 			do {
850
-				written = parport_write (port, crlf, i);
851
-				if (written > 0)
852
-					i -= written, crlf += written;
855
+				written = parport_write(port, crlf, i);
856
+				if (written > 0) {
857
+					i -= written;
858
+					crlf += written;
859
+				}
853
860
 			} while (i > 0 && (CONSOLE_LP_STRICT || written > 0));
854
861
 		}
855
862
 	} while (count > 0 && (CONSOLE_LP_STRICT || written > 0));
856
863
 
857
-	parport_release (dev);
864
+	parport_release(dev);
858
865
 }
859
866
 
860
867
 static struct console lpcons = {
..
..
@@ -875,7 +882,7 @@
875
882
 module_param(reset, bool, 0);
876
883
 
877
884
 #ifndef MODULE
878
-static int __init lp_setup (char *str)
885
+static int __init lp_setup(char *str)
879
886
 {
880
887
 	static int parport_ptr;
881
888
 	int x;
..
..
@@ -912,9 +919,13 @@
912
919
 
913
920
 static int lp_register(int nr, struct parport *port)
914
921
 {
915
-	lp_table[nr].dev = parport_register_device(port, "lp", 
916
-						   lp_preempt, NULL, NULL, 0,
917
-						   (void *) &lp_table[nr]);
922
+	struct pardev_cb ppdev_cb;
923
+
924
+	memset(&ppdev_cb, 0, sizeof(ppdev_cb));
925
+	ppdev_cb.preempt = lp_preempt;
926
+	ppdev_cb.private = &lp_table[nr];
927
+	lp_table[nr].dev = parport_register_dev_model(port, "lp",
928
+						      &ppdev_cb, nr);
918
929
 	if (lp_table[nr].dev == NULL)
919
930
 		return 1;
920
931
 	lp_table[nr].flags |= LP_EXIST;
..
..
@@ -925,7 +936,7 @@
925
936
 	device_create(lp_class, port->dev, MKDEV(LP_MAJOR, nr), NULL,
926
937
 		      "lp%d", nr);
927
938
 
928
-	printk(KERN_INFO "lp%d: using %s (%s).\n", nr, port->name, 
939
+	printk(KERN_INFO "lp%d: using %s (%s).\n", nr, port->name,
929
940
 	       (port->irq == PARPORT_IRQ_NONE)?"polling":"interrupt-driven");
930
941
 
931
942
 #ifdef CONFIG_LP_CONSOLE
..
..
@@ -933,17 +944,18 @@
933
944
 		if (port->modes & PARPORT_MODE_SAFEININT) {
934
945
 			register_console(&lpcons);
935
946
 			console_registered = port;
936
-			printk (KERN_INFO "lp%d: console ready\n", CONSOLE_LP);
947
+			printk(KERN_INFO "lp%d: console ready\n", CONSOLE_LP);
937
948
 		} else
938
-			printk (KERN_ERR "lp%d: cannot run console on %s\n",
939
-				CONSOLE_LP, port->name);
949
+			printk(KERN_ERR "lp%d: cannot run console on %s\n",
950
+			       CONSOLE_LP, port->name);
940
951
 	}
941
952
 #endif
953
+	port_num[nr] = port->number;
942
954
 
943
955
 	return 0;
944
956
 }
945
957
 
946
-static void lp_attach (struct parport *port)
958
+static void lp_attach(struct parport *port)
947
959
 {
948
960
 	unsigned int i;
949
961
 
..
..
@@ -957,7 +969,11 @@
957
969
 			printk(KERN_INFO "lp: ignoring parallel port (max. %d)\n",LP_NO);
958
970
 			return;
959
971
 		}
960
-		if (!lp_register(lp_count, port))
972
+		for (i = 0; i < LP_NO; i++)
973
+			if (port_num[i] == -1)
974
+				break;
975
+
976
+		if (!lp_register(i, port))
961
977
 			lp_count++;
962
978
 		break;
963
979
 
..
..
@@ -973,8 +989,10 @@
973
989
 	}
974
990
 }
975
991
 
976
-static void lp_detach (struct parport *port)
992
+static void lp_detach(struct parport *port)
977
993
 {
994
+	int n;
995
+
978
996
 	/* Write this some day. */
979
997
 #ifdef CONFIG_LP_CONSOLE
980
998
 	if (console_registered == port) {
..
..
@@ -982,15 +1000,25 @@
982
1000
 		console_registered = NULL;
983
1001
 	}
984
1002
 #endif /* CONFIG_LP_CONSOLE */
1003
+
1004
+	for (n = 0; n < LP_NO; n++) {
1005
+		if (port_num[n] == port->number) {
1006
+			port_num[n] = -1;
1007
+			lp_count--;
1008
+			device_destroy(lp_class, MKDEV(LP_MAJOR, n));
1009
+			parport_unregister_device(lp_table[n].dev);
1010
+		}
1011
+	}
985
1012
 }
986
1013
 
987
1014
 static struct parport_driver lp_driver = {
988
1015
 	.name = "lp",
989
-	.attach = lp_attach,
1016
+	.match_port = lp_attach,
990
1017
 	.detach = lp_detach,
1018
+	.devmodel = true,
991
1019
 };
992
1020
 
993
-static int __init lp_init (void)
1021
+static int __init lp_init(void)
994
1022
 {
995
1023
 	int i, err = 0;
996
1024
 
..
..
@@ -1007,17 +1035,18 @@
1007
1035
 #ifdef LP_STATS
1008
1036
 		lp_table[i].lastcall = 0;
1009
1037
 		lp_table[i].runchars = 0;
1010
-		memset (&lp_table[i].stats, 0, sizeof (struct lp_stats));
1038
+		memset(&lp_table[i].stats, 0, sizeof(struct lp_stats));
1011
1039
 #endif
1012
1040
 		lp_table[i].last_error = 0;
1013
-		init_waitqueue_head (&lp_table[i].waitq);
1014
-		init_waitqueue_head (&lp_table[i].dataq);
1041
+		init_waitqueue_head(&lp_table[i].waitq);
1042
+		init_waitqueue_head(&lp_table[i].dataq);
1015
1043
 		mutex_init(&lp_table[i].port_mutex);
1016
1044
 		lp_table[i].timeout = 10 * HZ;
1045
+		port_num[i] = -1;
1017
1046
 	}
1018
1047
 
1019
-	if (register_chrdev (LP_MAJOR, "lp", &lp_fops)) {
1020
-		printk (KERN_ERR "lp: unable to get major %d\n", LP_MAJOR);
1048
+	if (register_chrdev(LP_MAJOR, "lp", &lp_fops)) {
1049
+		printk(KERN_ERR "lp: unable to get major %d\n", LP_MAJOR);
1021
1050
 		return -EIO;
1022
1051
 	}
1023
1052
 
..
..
@@ -1027,17 +1056,17 @@
1027
1056
 		goto out_reg;
1028
1057
 	}
1029
1058
 
1030
-	if (parport_register_driver (&lp_driver)) {
1031
-		printk (KERN_ERR "lp: unable to register with parport\n");
1059
+	if (parport_register_driver(&lp_driver)) {
1060
+		printk(KERN_ERR "lp: unable to register with parport\n");
1032
1061
 		err = -EIO;
1033
1062
 		goto out_class;
1034
1063
 	}
1035
1064
 
1036
1065
 	if (!lp_count) {
1037
-		printk (KERN_INFO "lp: driver loaded but no devices found\n");
1066
+		printk(KERN_INFO "lp: driver loaded but no devices found\n");
1038
1067
 #ifndef CONFIG_PARPORT_1284
1039
1068
 		if (parport_nr[0] == LP_PARPORT_AUTO)
1040
-			printk (KERN_INFO "lp: (is IEEE 1284 support enabled?)\n");
1069
+			printk(KERN_INFO "lp: (is IEEE 1284 support enabled?)\n");
1041
1070
 #endif
1042
1071
 	}
1043
1072
 
..
..
@@ -1050,7 +1079,7 @@
1050
1079
 	return err;
1051
1080
 }
1052
1081
 
1053
-static int __init lp_init_module (void)
1082
+static int __init lp_init_module(void)
1054
1083
 {
1055
1084
 	if (parport[0]) {
1056
1085
 		/* The user gave some parameters.  Let's see what they were.  */
..
..
@@ -1064,7 +1093,7 @@
1064
1093
 				else {
1065
1094
 					char *ep;
1066
1095
 					unsigned long r = simple_strtoul(parport[n], &ep, 0);
1067
-					if (ep != parport[n]) 
1096
+					if (ep != parport[n])
1068
1097
 						parport_nr[n] = r;
1069
1098
 					else {
1070
1099
 						printk(KERN_ERR "lp: bad port specifier `%s'\n", parport[n]);
..
..
@@ -1078,23 +1107,15 @@
1078
1107
 	return lp_init();
1079
1108
 }
1080
1109
 
1081
-static void lp_cleanup_module (void)
1110
+static void lp_cleanup_module(void)
1082
1111
 {
1083
-	unsigned int offset;
1084
-
1085
-	parport_unregister_driver (&lp_driver);
1112
+	parport_unregister_driver(&lp_driver);
1086
1113
 
1087
1114
 #ifdef CONFIG_LP_CONSOLE
1088
-	unregister_console (&lpcons);
1115
+	unregister_console(&lpcons);
1089
1116
 #endif
1090
1117
 
1091
1118
 	unregister_chrdev(LP_MAJOR, "lp");
1092
-	for (offset = 0; offset < LP_NO; offset++) {
1093
-		if (lp_table[offset].dev == NULL)
1094
-			continue;
1095
-		parport_unregister_device(lp_table[offset].dev);
1096
-		device_destroy(lp_class, MKDEV(LP_MAJOR, offset));
1097
-	}
1098
1119
 	class_destroy(lp_class);
1099
1120
 }
1100
1121