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