?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Automatic merge of rsync://rsync.kernel.org/pub/scm/linux/kernel/git/gregkh/driver...
[linux-2.6/verdex.git] / drivers / block / acsi_slm.c
blobe3be8c31a74ccb5dbc8ef1005682239cd5d2d667
1 /*
2 * acsi_slm.c -- Device driver for the Atari SLM laser printer
3 *
4 * Copyright 1995 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file COPYING in the main directory of this archive for
8 * more details.
9 *
10 */
11
12 /*
13
14 Notes:
15
16 The major number for SLM printers is 28 (like ACSI), but as a character
17 device, not block device. The minor number is the number of the printer (if
18 you have more than one SLM; currently max. 2 (#define-constant) SLMs are
19 supported). The device can be opened for reading and writing. If reading it,
20 you get some status infos (MODE SENSE data). Writing mode is used for the data
21 to be printed. Some ioctls allow to get the printer status and to tune printer
22 modes and some internal variables.
23
24 A special problem of the SLM driver is the timing and thus the buffering of
25 the print data. The problem is that all the data for one page must be present
26 in memory when printing starts, else --when swapping occurs-- the timing could
27 not be guaranteed. There are several ways to assure this:
28
29 1) Reserve a buffer of 1196k (maximum page size) statically by
30 atari_stram_alloc(). The data are collected there until they're complete,
31 and then printing starts. Since the buffer is reserved, no further
32 considerations about memory and swapping are needed. So this is the
33 simplest method, but it needs a lot of memory for just the SLM.
34
35 An striking advantage of this method is (supposed the SLM_CONT_CNT_REPROG
36 method works, see there), that there are no timing problems with the DMA
37 anymore.
38
39 2) The other method would be to reserve the buffer dynamically each time
40 printing is required. I could think of looking at mem_map where the
41 largest unallocted ST-RAM area is, taking the area, and then extending it
42 by swapping out the neighbored pages, until the needed size is reached.
43 This requires some mm hacking, but seems possible. The only obstacle could
44 be pages that cannot be swapped out (reserved pages)...
45
46 3) Another possibility would be to leave the real data in user space and to
47 work with two dribble buffers of about 32k in the driver: While the one
48 buffer is DMAed to the SLM, the other can be filled with new data. But
49 to keep the timing, that requires that the user data remain in memory and
50 are not swapped out. Requires mm hacking, too, but maybe not so bad as
51 method 2).
52
53 */
54
55 #include <linux/module.h>
56
57 #include <linux/errno.h>
58 #include <linux/sched.h>
59 #include <linux/timer.h>
60 #include <linux/fs.h>
61 #include <linux/major.h>
62 #include <linux/kernel.h>
63 #include <linux/delay.h>
64 #include <linux/interrupt.h>
65 #include <linux/time.h>
66 #include <linux/mm.h>
67 #include <linux/slab.h>
68 #include <linux/devfs_fs_kernel.h>
69 #include <linux/smp_lock.h>
70
71 #include <asm/pgtable.h>
72 #include <asm/system.h>
73 #include <asm/uaccess.h>
74 #include <asm/atarihw.h>
75 #include <asm/atariints.h>
76 #include <asm/atari_acsi.h>
77 #include <asm/atari_stdma.h>
78 #include <asm/atari_stram.h>
79 #include <asm/atari_SLM.h>
80
81
82 #undef DEBUG
83
84 /* Define this if the page data are continuous in physical memory. That
85 * requires less reprogramming of the ST-DMA */
86 #define SLM_CONTINUOUS_DMA
87
88 /* Use continuous reprogramming of the ST-DMA counter register. This is
89 * --strictly speaking-- not allowed, Atari recommends not to look at the
90 * counter register while a DMA is going on. But I don't know if that applies
91 * only for reading the register, or also writing to it. Writing only works
92 * fine for me... The advantage is that the timing becomes absolutely
93 * uncritical: Just update each, say 200ms, the counter reg to its maximum,
94 * and the DMA will work until the status byte interrupt occurs.
95 */
96 #define SLM_CONT_CNT_REPROG
97
98 #define CMDSET_TARG_LUN(cmd,targ,lun) \
99 do { \
100 cmd[0] = (cmd[0] & ~0xe0) | (targ)<<5; \
101 cmd[1] = (cmd[1] & ~0xe0) | (lun)<<5; \
102 } while(0)
103
104 #define START_TIMER(to) mod_timer(&slm_timer, jiffies + (to))
105 #define STOP_TIMER() del_timer(&slm_timer)
106
107
108 static char slmreqsense_cmd[6] = { 0x03, 0, 0, 0, 0, 0 };
109 static char slmprint_cmd[6] = { 0x0a, 0, 0, 0, 0, 0 };
110 static char slminquiry_cmd[6] = { 0x12, 0, 0, 0, 0, 0x80 };
111 static char slmmsense_cmd[6] = { 0x1a, 0, 0, 0, 255, 0 };
112 #if 0
113 static char slmmselect_cmd[6] = { 0x15, 0, 0, 0, 0, 0 };
114 #endif
115
116
117 #define MAX_SLM 2
118
119 static struct slm {
120 unsigned target; /* target number */
121 unsigned lun; /* LUN in target controller */
122 atomic_t wr_ok; /* set to 0 if output part busy */
123 atomic_t rd_ok; /* set to 0 if status part busy */
124 } slm_info[MAX_SLM];
125
126 int N_SLM_Printers = 0;
127
128 /* printer buffer */
129 static unsigned char *SLMBuffer; /* start of buffer */
130 static unsigned char *BufferP; /* current position in buffer */
131 static int BufferSize; /* length of buffer for page size */
132
133 typedef enum { IDLE, FILLING, PRINTING } SLMSTATE;
134 static SLMSTATE SLMState;
135 static int SLMBufOwner; /* SLM# currently using the buffer */
136
137 /* DMA variables */
138 #ifndef SLM_CONT_CNT_REPROG
139 static unsigned long SLMCurAddr; /* current base addr of DMA chunk */
140 static unsigned long SLMEndAddr; /* expected end addr */
141 static unsigned long SLMSliceSize; /* size of one DMA chunk */
142 #endif
143 static int SLMError;
144
145 /* wait queues */
146 static DECLARE_WAIT_QUEUE_HEAD(slm_wait); /* waiting for buffer */
147 static DECLARE_WAIT_QUEUE_HEAD(print_wait); /* waiting for printing finished */
148
149 /* status codes */
150 #define SLMSTAT_OK 0x00
151 #define SLMSTAT_ORNERY 0x02
152 #define SLMSTAT_TONER 0x03
153 #define SLMSTAT_WARMUP 0x04
154 #define SLMSTAT_PAPER 0x05
155 #define SLMSTAT_DRUM 0x06
156 #define SLMSTAT_INJAM 0x07
157 #define SLMSTAT_THRJAM 0x08
158 #define SLMSTAT_OUTJAM 0x09
159 #define SLMSTAT_COVER 0x0a
160 #define SLMSTAT_FUSER 0x0b
161 #define SLMSTAT_IMAGER 0x0c
162 #define SLMSTAT_MOTOR 0x0d
163 #define SLMSTAT_VIDEO 0x0e
164 #define SLMSTAT_SYSTO 0x10
165 #define SLMSTAT_OPCODE 0x12
166 #define SLMSTAT_DEVNUM 0x15
167 #define SLMSTAT_PARAM 0x1a
168 #define SLMSTAT_ACSITO 0x1b /* driver defined */
169 #define SLMSTAT_NOTALL 0x1c /* driver defined */
170
171 static char *SLMErrors[] = {
172 /* 0x00 */ "OK and ready",
173 /* 0x01 */ NULL,
174 /* 0x02 */ "ornery printer",
175 /* 0x03 */ "toner empty",
176 /* 0x04 */ "warming up",
177 /* 0x05 */ "paper empty",
178 /* 0x06 */ "drum empty",
179 /* 0x07 */ "input jam",
180 /* 0x08 */ "through jam",
181 /* 0x09 */ "output jam",
182 /* 0x0a */ "cover open",
183 /* 0x0b */ "fuser malfunction",
184 /* 0x0c */ "imager malfunction",
185 /* 0x0d */ "motor malfunction",
186 /* 0x0e */ "video malfunction",
187 /* 0x0f */ NULL,
188 /* 0x10 */ "printer system timeout",
189 /* 0x11 */ NULL,
190 /* 0x12 */ "invalid operation code",
191 /* 0x13 */ NULL,
192 /* 0x14 */ NULL,
193 /* 0x15 */ "invalid device number",
194 /* 0x16 */ NULL,
195 /* 0x17 */ NULL,
196 /* 0x18 */ NULL,
197 /* 0x19 */ NULL,
198 /* 0x1a */ "invalid parameter list",
199 /* 0x1b */ "ACSI timeout",
200 /* 0x1c */ "not all printed"
201 };
202
203 #define N_ERRORS (sizeof(SLMErrors)/sizeof(*SLMErrors))
204
205 /* real (driver caused) error? */
206 #define IS_REAL_ERROR(x) (x > 0x10)
207
208
209 static struct {
210 char *name;
211 int w, h;
212 } StdPageSize[] = {
213 { "Letter", 2400, 3180 },
214 { "Legal", 2400, 4080 },
215 { "A4", 2336, 3386 },
216 { "B5", 2016, 2914 }
217 };
218
219 #define N_STD_SIZES (sizeof(StdPageSize)/sizeof(*StdPageSize))
220
221 #define SLM_BUFFER_SIZE (2336*3386/8) /* A4 for now */
222 #define SLM_DMA_AMOUNT 255 /* #sectors to program the DMA for */
223
224 #ifdef SLM_CONTINUOUS_DMA
225 # define SLM_DMA_INT_OFFSET 0 /* DMA goes until seccnt 0, no offs */
226 # define SLM_DMA_END_OFFSET 32 /* 32 Byte ST-DMA FIFO */
227 # define SLM_SLICE_SIZE(w) (255*512)
228 #else
229 # define SLM_DMA_INT_OFFSET 32 /* 32 Byte ST-DMA FIFO */
230 # define SLM_DMA_END_OFFSET 32 /* 32 Byte ST-DMA FIFO */
231 # define SLM_SLICE_SIZE(w) ((254*512)/(w/8)*(w/8))
232 #endif
233
234 /* calculate the number of jiffies to wait for 'n' bytes */
235 #ifdef SLM_CONT_CNT_REPROG
236 #define DMA_TIME_FOR(n) 50
237 #define DMA_STARTUP_TIME 0
238 #else
239 #define DMA_TIME_FOR(n) (n/1400-1)
240 #define DMA_STARTUP_TIME 650
241 #endif
242
243 /***************************** Prototypes *****************************/
244
245 static char *slm_errstr( int stat );
246 static int slm_getstats( char *buffer, int device );
247 static ssize_t slm_read( struct file* file, char *buf, size_t count, loff_t
248 *ppos );
249 static void start_print( int device );
250 static irqreturn_t slm_interrupt(int irc, void *data, struct pt_regs *fp);
251 static void slm_test_ready( unsigned long dummy );
252 static void set_dma_addr( unsigned long paddr );
253 static unsigned long get_dma_addr( void );
254 static ssize_t slm_write( struct file *file, const char *buf, size_t count,
255 loff_t *ppos );
256 static int slm_ioctl( struct inode *inode, struct file *file, unsigned int
257 cmd, unsigned long arg );
258 static int slm_open( struct inode *inode, struct file *file );
259 static int slm_release( struct inode *inode, struct file *file );
260 static int slm_req_sense( int device );
261 static int slm_mode_sense( int device, char *buffer, int abs_flag );
262 #if 0
263 static int slm_mode_select( int device, char *buffer, int len, int
264 default_flag );
265 #endif
266 static int slm_get_pagesize( int device, int *w, int *h );
267
268 /************************* End of Prototypes **************************/
269
270
271 static struct timer_list slm_timer = TIMER_INITIALIZER(slm_test_ready, 0, 0);
272
273 static struct file_operations slm_fops = {
274 .owner = THIS_MODULE,
275 .read = slm_read,
276 .write = slm_write,
277 .ioctl = slm_ioctl,
278 .open = slm_open,
279 .release = slm_release,
280 };
281
282
283 /* ---------------------------------------------------------------------- */
284 /* Status Functions */
285
286
287 static char *slm_errstr( int stat )
288
289 { char *p;
290 static char str[22];
291
292 stat &= 0x1f;
293 if (stat >= 0 && stat < N_ERRORS && (p = SLMErrors[stat]))
294 return( p );
295 sprintf( str, "unknown status 0x%02x", stat );
296 return( str );
297 }
298
299
300 static int slm_getstats( char *buffer, int device )
301
302 { int len = 0, stat, i, w, h;
303 unsigned char buf[256];
304
305 stat = slm_mode_sense( device, buf, 0 );
306 if (IS_REAL_ERROR(stat))
307 return( -EIO );
308
309 #define SHORTDATA(i) ((buf[i] << 8) | buf[i+1])
310 #define BOOLDATA(i,mask) ((buf[i] & mask) ? "on" : "off")
311
312 w = SHORTDATA( 3 );
313 h = SHORTDATA( 1 );
314
315 len += sprintf( buffer+len, "Status\t\t%s\n",
316 slm_errstr( stat ) );
317 len += sprintf( buffer+len, "Page Size\t%dx%d",
318 w, h );
319
320 for( i = 0; i < N_STD_SIZES; ++i ) {
321 if (w == StdPageSize[i].w && h == StdPageSize[i].h)
322 break;
323 }
324 if (i < N_STD_SIZES)
325 len += sprintf( buffer+len, " (%s)", StdPageSize[i].name );
326 buffer[len++] = '\n';
327
328 len += sprintf( buffer+len, "Top/Left Margin\t%d/%d\n",
329 SHORTDATA( 5 ), SHORTDATA( 7 ) );
330 len += sprintf( buffer+len, "Manual Feed\t%s\n",
331 BOOLDATA( 9, 0x01 ) );
332 len += sprintf( buffer+len, "Input Select\t%d\n",
333 (buf[9] >> 1) & 7 );
334 len += sprintf( buffer+len, "Auto Select\t%s\n",
335 BOOLDATA( 9, 0x10 ) );
336 len += sprintf( buffer+len, "Prefeed Paper\t%s\n",
337 BOOLDATA( 9, 0x20 ) );
338 len += sprintf( buffer+len, "Thick Pixels\t%s\n",
339 BOOLDATA( 9, 0x40 ) );
340 len += sprintf( buffer+len, "H/V Resol.\t%d/%d dpi\n",
341 SHORTDATA( 12 ), SHORTDATA( 10 ) );
342 len += sprintf( buffer+len, "System Timeout\t%d\n",
343 buf[14] );
344 len += sprintf( buffer+len, "Scan Time\t%d\n",
345 SHORTDATA( 15 ) );
346 len += sprintf( buffer+len, "Page Count\t%d\n",
347 SHORTDATA( 17 ) );
348 len += sprintf( buffer+len, "In/Out Cap.\t%d/%d\n",
349 SHORTDATA( 19 ), SHORTDATA( 21 ) );
350 len += sprintf( buffer+len, "Stagger Output\t%s\n",
351 BOOLDATA( 23, 0x01 ) );
352 len += sprintf( buffer+len, "Output Select\t%d\n",
353 (buf[23] >> 1) & 7 );
354 len += sprintf( buffer+len, "Duplex Print\t%s\n",
355 BOOLDATA( 23, 0x10 ) );
356 len += sprintf( buffer+len, "Color Sep.\t%s\n",
357 BOOLDATA( 23, 0x20 ) );
358
359 return( len );
360 }
361
362
363 static ssize_t slm_read( struct file *file, char *buf, size_t count,
364 loff_t *ppos )
365
366 {
367 struct inode *node = file->f_dentry->d_inode;
368 unsigned long page;
369 int length;
370 int end;
371
372 if (count < 0)
373 return( -EINVAL );
374 if (!(page = __get_free_page( GFP_KERNEL )))
375 return( -ENOMEM );
376
377 length = slm_getstats( (char *)page, iminor(node) );
378 if (length < 0) {
379 count = length;
380 goto out;
381 }
382 if (file->f_pos >= length) {
383 count = 0;
384 goto out;
385 }
386 if (count + file->f_pos > length)
387 count = length - file->f_pos;
388 end = count + file->f_pos;
389 if (copy_to_user(buf, (char *)page + file->f_pos, count)) {
390 count = -EFAULT;
391 goto out;
392 }
393 file->f_pos = end;
394 out: free_page( page );
395 return( count );
396 }
397
398
399 /* ---------------------------------------------------------------------- */
400 /* Printing */
401
402
403 static void start_print( int device )
404
405 { struct slm *sip = &slm_info[device];
406 unsigned char *cmd;
407 unsigned long paddr;
408 int i;
409
410 stdma_lock( slm_interrupt, NULL );
411
412 CMDSET_TARG_LUN( slmprint_cmd, sip->target, sip->lun );
413 cmd = slmprint_cmd;
414 paddr = virt_to_phys( SLMBuffer );
415 dma_cache_maintenance( paddr, virt_to_phys(BufferP)-paddr, 1 );
416 DISABLE_IRQ();
417
418 /* Low on A1 */
419 dma_wd.dma_mode_status = 0x88;
420 MFPDELAY();
421
422 /* send the command bytes except the last */
423 for( i = 0; i < 5; ++i ) {
424 DMA_LONG_WRITE( *cmd++, 0x8a );
425 udelay(20);
426 if (!acsi_wait_for_IRQ( HZ/2 )) {
427 SLMError = 1;
428 return; /* timeout */
429 }
430 }
431 /* last command byte */
432 DMA_LONG_WRITE( *cmd++, 0x82 );
433 MFPDELAY();
434 /* set DMA address */
435 set_dma_addr( paddr );
436 /* program DMA for write and select sector counter reg */
437 dma_wd.dma_mode_status = 0x192;
438 MFPDELAY();
439 /* program for 255*512 bytes and start DMA */
440 DMA_LONG_WRITE( SLM_DMA_AMOUNT, 0x112 );
441
442 #ifndef SLM_CONT_CNT_REPROG
443 SLMCurAddr = paddr;
444 SLMEndAddr = paddr + SLMSliceSize + SLM_DMA_INT_OFFSET;
445 #endif
446 START_TIMER( DMA_STARTUP_TIME + DMA_TIME_FOR( SLMSliceSize ));
447 #if !defined(SLM_CONT_CNT_REPROG) && defined(DEBUG)
448 printk( "SLM: CurAddr=%#lx EndAddr=%#lx timer=%ld\n",
449 SLMCurAddr, SLMEndAddr, DMA_TIME_FOR( SLMSliceSize ) );
450 #endif
451
452 ENABLE_IRQ();
453 }
454
455
456 /* Only called when an error happened or at the end of a page */
457
458 static irqreturn_t slm_interrupt(int irc, void *data, struct pt_regs *fp)
459
460 { unsigned long addr;
461 int stat;
462
463 STOP_TIMER();
464 addr = get_dma_addr();
465 stat = acsi_getstatus();
466 SLMError = (stat < 0) ? SLMSTAT_ACSITO :
467 (addr < virt_to_phys(BufferP)) ? SLMSTAT_NOTALL :
468 stat;
469
470 dma_wd.dma_mode_status = 0x80;
471 MFPDELAY();
472 #ifdef DEBUG
473 printk( "SLM: interrupt, addr=%#lx, error=%d\n", addr, SLMError );
474 #endif
475
476 wake_up( &print_wait );
477 stdma_release();
478 ENABLE_IRQ();
479 return IRQ_HANDLED;
480 }
481
482
483 static void slm_test_ready( unsigned long dummy )
484
485 {
486 #ifdef SLM_CONT_CNT_REPROG
487 /* program for 255*512 bytes again */
488 dma_wd.fdc_acces_seccount = SLM_DMA_AMOUNT;
489 START_TIMER( DMA_TIME_FOR(0) );
490 #ifdef DEBUG
491 printk( "SLM: reprogramming timer for %d jiffies, addr=%#lx\n",
492 DMA_TIME_FOR(0), get_dma_addr() );
493 #endif
494
495 #else /* !SLM_CONT_CNT_REPROG */
496
497 unsigned long flags, addr;
498 int d, ti;
499 #ifdef DEBUG
500 struct timeval start_tm, end_tm;
501 int did_wait = 0;
502 #endif
503
504 local_irq_save(flags);
505
506 addr = get_dma_addr();
507 if ((d = SLMEndAddr - addr) > 0) {
508 local_irq_restore(flags);
509
510 /* slice not yet finished, decide whether to start another timer or to
511 * busy-wait */
512 ti = DMA_TIME_FOR( d );
513 if (ti > 0) {
514 #ifdef DEBUG
515 printk( "SLM: reprogramming timer for %d jiffies, rest %d bytes\n",
516 ti, d );
517 #endif
518 START_TIMER( ti );
519 return;
520 }
521 /* wait for desired end address to be reached */
522 #ifdef DEBUG
523 do_gettimeofday( &start_tm );
524 did_wait = 1;
525 #endif
526 local_irq_disable();
527 while( get_dma_addr() < SLMEndAddr )
528 barrier();
529 }
530
531 /* slice finished, start next one */
532 SLMCurAddr += SLMSliceSize;
533
534 #ifdef SLM_CONTINUOUS_DMA
535 /* program for 255*512 bytes again */
536 dma_wd.fdc_acces_seccount = SLM_DMA_AMOUNT;
537 #else
538 /* set DMA address;
539 * add 2 bytes for the ones in the SLM controller FIFO! */
540 set_dma_addr( SLMCurAddr + 2 );
541 /* toggle DMA to write and select sector counter reg */
542 dma_wd.dma_mode_status = 0x92;
543 MFPDELAY();
544 dma_wd.dma_mode_status = 0x192;
545 MFPDELAY();
546 /* program for 255*512 bytes and start DMA */
547 DMA_LONG_WRITE( SLM_DMA_AMOUNT, 0x112 );
548 #endif
549
550 local_irq_restore(flags);
551
552 #ifdef DEBUG
553 if (did_wait) {
554 int ms;
555 do_gettimeofday( &end_tm );
556 ms = (end_tm.tv_sec*1000000+end_tm.tv_usec) -
557 (start_tm.tv_sec*1000000+start_tm.tv_usec);
558 printk( "SLM: did %ld.%ld ms busy waiting for %d bytes\n",
559 ms/1000, ms%1000, d );
560 }
561 else
562 printk( "SLM: didn't wait (!)\n" );
563 #endif
564
565 if ((unsigned char *)PTOV( SLMCurAddr + SLMSliceSize ) >= BufferP) {
566 /* will be last slice, no timer necessary */
567 #ifdef DEBUG
568 printk( "SLM: CurAddr=%#lx EndAddr=%#lx last slice -> no timer\n",
569 SLMCurAddr, SLMEndAddr );
570 #endif
571 }
572 else {
573 /* not last slice */
574 SLMEndAddr = SLMCurAddr + SLMSliceSize + SLM_DMA_INT_OFFSET;
575 START_TIMER( DMA_TIME_FOR( SLMSliceSize ));
576 #ifdef DEBUG
577 printk( "SLM: CurAddr=%#lx EndAddr=%#lx timer=%ld\n",
578 SLMCurAddr, SLMEndAddr, DMA_TIME_FOR( SLMSliceSize ) );
579 #endif
580 }
581 #endif /* SLM_CONT_CNT_REPROG */
582 }
583
584
585 static void set_dma_addr( unsigned long paddr )
586
587 { unsigned long flags;
588
589 local_irq_save(flags);
590 dma_wd.dma_lo = (unsigned char)paddr;
591 paddr >>= 8;
592 MFPDELAY();
593 dma_wd.dma_md = (unsigned char)paddr;
594 paddr >>= 8;
595 MFPDELAY();
596 if (ATARIHW_PRESENT( EXTD_DMA ))
597 st_dma_ext_dmahi = (unsigned short)paddr;
598 else
599 dma_wd.dma_hi = (unsigned char)paddr;
600 MFPDELAY();
601 local_irq_restore(flags);
602 }
603
604
605 static unsigned long get_dma_addr( void )
606
607 { unsigned long addr;
608
609 addr = dma_wd.dma_lo & 0xff;
610 MFPDELAY();
611 addr |= (dma_wd.dma_md & 0xff) << 8;
612 MFPDELAY();
613 addr |= (dma_wd.dma_hi & 0xff) << 16;
614 MFPDELAY();
615
616 return( addr );
617 }
618
619
620 static ssize_t slm_write( struct file *file, const char *buf, size_t count,
621 loff_t *ppos )
622
623 {
624 struct inode *node = file->f_dentry->d_inode;
625 int device = iminor(node);
626 int n, filled, w, h;
627
628 while( SLMState == PRINTING ||
629 (SLMState == FILLING && SLMBufOwner != device) ) {
630 interruptible_sleep_on( &slm_wait );
631 if (signal_pending(current))
632 return( -ERESTARTSYS );
633 }
634 if (SLMState == IDLE) {
635 /* first data of page: get current page size */
636 if (slm_get_pagesize( device, &w, &h ))
637 return( -EIO );
638 BufferSize = w*h/8;
639 if (BufferSize > SLM_BUFFER_SIZE)
640 return( -ENOMEM );
641
642 SLMState = FILLING;
643 SLMBufOwner = device;
644 }
645
646 n = count;
647 filled = BufferP - SLMBuffer;
648 if (filled + n > BufferSize)
649 n = BufferSize - filled;
650
651 if (copy_from_user(BufferP, buf, n))
652 return -EFAULT;
653 BufferP += n;
654 filled += n;
655
656 if (filled == BufferSize) {
657 /* Check the paper size again! The user may have switched it in the
658 * time between starting the data and finishing them. Would end up in
659 * a trashy page... */
660 if (slm_get_pagesize( device, &w, &h ))
661 return( -EIO );
662 if (BufferSize != w*h/8) {
663 printk( KERN_NOTICE "slm%d: page size changed while printing\n",
664 device );
665 return( -EAGAIN );
666 }
667
668 SLMState = PRINTING;
669 /* choose a slice size that is a multiple of the line size */
670 #ifndef SLM_CONT_CNT_REPROG
671 SLMSliceSize = SLM_SLICE_SIZE(w);
672 #endif
673
674 start_print( device );
675 sleep_on( &print_wait );
676 if (SLMError && IS_REAL_ERROR(SLMError)) {
677 printk( KERN_ERR "slm%d: %s\n", device, slm_errstr(SLMError) );
678 n = -EIO;
679 }
680
681 SLMState = IDLE;
682 BufferP = SLMBuffer;
683 wake_up_interruptible( &slm_wait );
684 }
685
686 return( n );
687 }
688
689
690 /* ---------------------------------------------------------------------- */
691 /* ioctl Functions */
692
693
694 static int slm_ioctl( struct inode *inode, struct file *file,
695 unsigned int cmd, unsigned long arg )
696
697 { int device = iminor(inode), err;
698
699 /* I can think of setting:
700 * - manual feed
701 * - paper format
702 * - copy count
703 * - ...
704 * but haven't implemented that yet :-)
705 * BTW, has anybody better docs about the MODE SENSE/MODE SELECT data?
706 */
707 switch( cmd ) {
708
709 case SLMIORESET: /* reset buffer, i.e. empty the buffer */
710 if (!(file->f_mode & 2))
711 return( -EINVAL );
712 if (SLMState == PRINTING)
713 return( -EBUSY );
714 SLMState = IDLE;
715 BufferP = SLMBuffer;
716 wake_up_interruptible( &slm_wait );
717 return( 0 );
718
719 case SLMIOGSTAT: { /* get status */
720 int stat;
721 char *str;
722
723 stat = slm_req_sense( device );
724 if (arg) {
725 str = slm_errstr( stat );
726 if (put_user(stat,
727 (long *)&((struct SLM_status *)arg)->stat))
728 return -EFAULT;
729 if (copy_to_user( ((struct SLM_status *)arg)->str, str,
730 strlen(str) + 1))
731 return -EFAULT;
732 }
733 return( stat );
734 }
735
736 case SLMIOGPSIZE: { /* get paper size */
737 int w, h;
738
739 if ((err = slm_get_pagesize( device, &w, &h ))) return( err );
740
741 if (put_user(w, (long *)&((struct SLM_paper_size *)arg)->width))
742 return -EFAULT;
743 if (put_user(h, (long *)&((struct SLM_paper_size *)arg)->height))
744 return -EFAULT;
745 return( 0 );
746 }
747
748 case SLMIOGMFEED: /* get manual feed */
749 return( -EINVAL );
750
751 case SLMIOSPSIZE: /* set paper size */
752 return( -EINVAL );
753
754 case SLMIOSMFEED: /* set manual feed */
755 return( -EINVAL );
756
757 }
758 return( -EINVAL );
759 }
760
761
762 /* ---------------------------------------------------------------------- */
763 /* Opening and Closing */
764
765
766 static int slm_open( struct inode *inode, struct file *file )
767
768 { int device;
769 struct slm *sip;
770
771 device = iminor(inode);
772 if (device >= N_SLM_Printers)
773 return( -ENXIO );
774 sip = &slm_info[device];
775
776 if (file->f_mode & 2) {
777 /* open for writing is exclusive */
778 if ( !atomic_dec_and_test(&sip->wr_ok) ) {
779 atomic_inc(&sip->wr_ok);
780 return( -EBUSY );
781 }
782 }
783 if (file->f_mode & 1) {
784 /* open for reading is exclusive */
785 if ( !atomic_dec_and_test(&sip->rd_ok) ) {
786 atomic_inc(&sip->rd_ok);
787 return( -EBUSY );
788 }
789 }
790
791 return( 0 );
792 }
793
794
795 static int slm_release( struct inode *inode, struct file *file )
796
797 { int device;
798 struct slm *sip;
799
800 device = iminor(inode);
801 sip = &slm_info[device];
802
803 if (file->f_mode & 2)
804 atomic_inc( &sip->wr_ok );
805 if (file->f_mode & 1)
806 atomic_inc( &sip->rd_ok );
807
808 return( 0 );
809 }
810
811
812 /* ---------------------------------------------------------------------- */
813 /* ACSI Primitives for the SLM */
814
815
816 static int slm_req_sense( int device )
817
818 { int stat, rv;
819 struct slm *sip = &slm_info[device];
820
821 stdma_lock( NULL, NULL );
822
823 CMDSET_TARG_LUN( slmreqsense_cmd, sip->target, sip->lun );
824 if (!acsicmd_nodma( slmreqsense_cmd, 0 ) ||
825 (stat = acsi_getstatus()) < 0)
826 rv = SLMSTAT_ACSITO;
827 else
828 rv = stat & 0x1f;
829
830 ENABLE_IRQ();
831 stdma_release();
832 return( rv );
833 }
834
835
836 static int slm_mode_sense( int device, char *buffer, int abs_flag )
837
838 { unsigned char stat, len;
839 int rv = 0;
840 struct slm *sip = &slm_info[device];
841
842 stdma_lock( NULL, NULL );
843
844 CMDSET_TARG_LUN( slmmsense_cmd, sip->target, sip->lun );
845 slmmsense_cmd[5] = abs_flag ? 0x80 : 0;
846 if (!acsicmd_nodma( slmmsense_cmd, 0 )) {
847 rv = SLMSTAT_ACSITO;
848 goto the_end;
849 }
850
851 if (!acsi_extstatus( &stat, 1 )) {
852 acsi_end_extstatus();
853 rv = SLMSTAT_ACSITO;
854 goto the_end;
855 }
856
857 if (!acsi_extstatus( &len, 1 )) {
858 acsi_end_extstatus();
859 rv = SLMSTAT_ACSITO;
860 goto the_end;
861 }
862 buffer[0] = len;
863 if (!acsi_extstatus( buffer+1, len )) {
864 acsi_end_extstatus();
865 rv = SLMSTAT_ACSITO;
866 goto the_end;
867 }
868
869 acsi_end_extstatus();
870 rv = stat & 0x1f;
871
872 the_end:
873 ENABLE_IRQ();
874 stdma_release();
875 return( rv );
876 }
877
878
879 #if 0
880 /* currently unused */
881 static int slm_mode_select( int device, char *buffer, int len,
882 int default_flag )
883
884 { int stat, rv;
885 struct slm *sip = &slm_info[device];
886
887 stdma_lock( NULL, NULL );
888
889 CMDSET_TARG_LUN( slmmselect_cmd, sip->target, sip->lun );
890 slmmselect_cmd[5] = default_flag ? 0x80 : 0;
891 if (!acsicmd_nodma( slmmselect_cmd, 0 )) {
892 rv = SLMSTAT_ACSITO;
893 goto the_end;
894 }
895
896 if (!default_flag) {
897 unsigned char c = len;
898 if (!acsi_extcmd( &c, 1 )) {
899 rv = SLMSTAT_ACSITO;
900 goto the_end;
901 }
902 if (!acsi_extcmd( buffer, len )) {
903 rv = SLMSTAT_ACSITO;
904 goto the_end;
905 }
906 }
907
908 stat = acsi_getstatus();
909 rv = (stat < 0 ? SLMSTAT_ACSITO : stat);
910
911 the_end:
912 ENABLE_IRQ();
913 stdma_release();
914 return( rv );
915 }
916 #endif
917
918
919 static int slm_get_pagesize( int device, int *w, int *h )
920
921 { char buf[256];
922 int stat;
923
924 stat = slm_mode_sense( device, buf, 0 );
925 ENABLE_IRQ();
926 stdma_release();
927
928 if (stat != SLMSTAT_OK)
929 return( -EIO );
930
931 *w = (buf[3] << 8) | buf[4];
932 *h = (buf[1] << 8) | buf[2];
933 return( 0 );
934 }
935
936
937 /* ---------------------------------------------------------------------- */
938 /* Initialization */
939
940
941 int attach_slm( int target, int lun )
942
943 { static int did_register;
944 int len;
945
946 if (N_SLM_Printers >= MAX_SLM) {
947 printk( KERN_WARNING "Too much SLMs\n" );
948 return( 0 );
949 }
950
951 /* do an INQUIRY */
952 udelay(100);
953 CMDSET_TARG_LUN( slminquiry_cmd, target, lun );
954 if (!acsicmd_nodma( slminquiry_cmd, 0 )) {
955 inq_timeout:
956 printk( KERN_ERR "SLM inquiry command timed out.\n" );
957 inq_fail:
958 acsi_end_extstatus();
959 return( 0 );
960 }
961 /* read status and header of return data */
962 if (!acsi_extstatus( SLMBuffer, 6 ))
963 goto inq_timeout;
964
965 if (SLMBuffer[1] != 2) { /* device type == printer? */
966 printk( KERN_ERR "SLM inquiry returned device type != printer\n" );
967 goto inq_fail;
968 }
969 len = SLMBuffer[5];
970
971 /* read id string */
972 if (!acsi_extstatus( SLMBuffer, len ))
973 goto inq_timeout;
974 acsi_end_extstatus();
975 SLMBuffer[len] = 0;
976
977 if (!did_register) {
978 did_register = 1;
979 }
980
981 slm_info[N_SLM_Printers].target = target;
982 slm_info[N_SLM_Printers].lun = lun;
983 atomic_set(&slm_info[N_SLM_Printers].wr_ok, 1 );
984 atomic_set(&slm_info[N_SLM_Printers].rd_ok, 1 );
985
986 printk( KERN_INFO " Printer: %s\n", SLMBuffer );
987 printk( KERN_INFO "Detected slm%d at id %d lun %d\n",
988 N_SLM_Printers, target, lun );
989 N_SLM_Printers++;
990 return( 1 );
991 }
992
993 int slm_init( void )
994
995 {
996 int i;
997 if (register_chrdev( ACSI_MAJOR, "slm", &slm_fops )) {
998 printk( KERN_ERR "Unable to get major %d for ACSI SLM\n", ACSI_MAJOR );
999 return -EBUSY;
1000 }
1001
1002 if (!(SLMBuffer = atari_stram_alloc( SLM_BUFFER_SIZE, "SLM" ))) {
1003 printk( KERN_ERR "Unable to get SLM ST-Ram buffer.\n" );
1004 unregister_chrdev( ACSI_MAJOR, "slm" );
1005 return -ENOMEM;
1006 }
1007 BufferP = SLMBuffer;
1008 SLMState = IDLE;
1009
1010 devfs_mk_dir("slm");
1011 for (i = 0; i < MAX_SLM; i++) {
1012 devfs_mk_cdev(MKDEV(ACSI_MAJOR, i),
1013 S_IFCHR|S_IRUSR|S_IWUSR, "slm/%d", i);
1014 }
1015 return 0;
1016 }
1017
1018 #ifdef MODULE
1019
1020 /* from acsi.c */
1021 void acsi_attach_SLMs( int (*attach_func)( int, int ) );
1022
1023 int init_module(void)
1024 {
1025 int err;
1026
1027 if ((err = slm_init()))
1028 return( err );
1029 /* This calls attach_slm() for every target/lun where acsi.c detected a
1030 * printer */
1031 acsi_attach_SLMs( attach_slm );
1032 return( 0 );
1033 }
1034
1035 void cleanup_module(void)
1036 {
1037 int i;
1038 for (i = 0; i < MAX_SLM; i++)
1039 devfs_remove("slm/%d", i);
1040 devfs_remove("slm");
1041 if (unregister_chrdev( ACSI_MAJOR, "slm" ) != 0)
1042 printk( KERN_ERR "acsi_slm: cleanup_module failed\n");
1043 atari_stram_free( SLMBuffer );
1044 }
1045 #endif
Verdex Pro support