drm: radeon constify radeon microcode
[linux-2.6] / 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/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 DEFINE_TIMER(slm_timer, 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 (!(page = __get_free_page( GFP_KERNEL )))
373                 return( -ENOMEM );
374         
375         length = slm_getstats( (char *)page, iminor(node) );
376         if (length < 0) {
377                 count = length;
378                 goto out;
379         }
380         if (file->f_pos >= length) {
381                 count = 0;
382                 goto out;
383         }
384         if (count + file->f_pos > length)
385                 count = length - file->f_pos;
386         end = count + file->f_pos;
387         if (copy_to_user(buf, (char *)page + file->f_pos, count)) {
388                 count = -EFAULT;
389                 goto out;
390         }
391         file->f_pos = end;
392 out:    free_page( page );
393         return( count );
394 }
395
396
397 /* ---------------------------------------------------------------------- */
398 /*                                                                 Printing                                                               */
399
400
401 static void start_print( int device )
402
403 {       struct slm *sip = &slm_info[device];
404         unsigned char   *cmd;
405         unsigned long   paddr;
406         int                             i;
407         
408         stdma_lock( slm_interrupt, NULL );
409
410         CMDSET_TARG_LUN( slmprint_cmd, sip->target, sip->lun );
411         cmd = slmprint_cmd;
412         paddr = virt_to_phys( SLMBuffer );
413         dma_cache_maintenance( paddr, virt_to_phys(BufferP)-paddr, 1 );
414         DISABLE_IRQ();
415
416         /* Low on A1 */
417         dma_wd.dma_mode_status = 0x88;
418         MFPDELAY();
419
420         /* send the command bytes except the last */
421         for( i = 0; i < 5; ++i ) {
422                 DMA_LONG_WRITE( *cmd++, 0x8a );
423                 udelay(20);
424                 if (!acsi_wait_for_IRQ( HZ/2 )) {
425                         SLMError = 1;
426                         return; /* timeout */
427                 }
428         }
429         /* last command byte */
430         DMA_LONG_WRITE( *cmd++, 0x82 );
431         MFPDELAY();
432         /* set DMA address */
433         set_dma_addr( paddr );
434         /* program DMA for write and select sector counter reg */
435         dma_wd.dma_mode_status = 0x192;
436         MFPDELAY();
437         /* program for 255*512 bytes and start DMA */
438         DMA_LONG_WRITE( SLM_DMA_AMOUNT, 0x112 );
439
440 #ifndef SLM_CONT_CNT_REPROG
441         SLMCurAddr = paddr;
442         SLMEndAddr = paddr + SLMSliceSize + SLM_DMA_INT_OFFSET;
443 #endif
444         START_TIMER( DMA_STARTUP_TIME + DMA_TIME_FOR( SLMSliceSize ));
445 #if !defined(SLM_CONT_CNT_REPROG) && defined(DEBUG)
446         printk( "SLM: CurAddr=%#lx EndAddr=%#lx timer=%ld\n",
447                         SLMCurAddr, SLMEndAddr, DMA_TIME_FOR( SLMSliceSize ) );
448 #endif
449         
450         ENABLE_IRQ();
451 }
452
453
454 /* Only called when an error happened or at the end of a page */
455
456 static irqreturn_t slm_interrupt(int irc, void *data, struct pt_regs *fp)
457
458 {       unsigned long   addr;
459         int                             stat;
460         
461         STOP_TIMER();
462         addr = get_dma_addr();
463         stat = acsi_getstatus();
464         SLMError = (stat < 0)             ? SLMSTAT_ACSITO :
465                        (addr < virt_to_phys(BufferP)) ? SLMSTAT_NOTALL :
466                                                                             stat;
467
468         dma_wd.dma_mode_status = 0x80;
469         MFPDELAY();
470 #ifdef DEBUG
471         printk( "SLM: interrupt, addr=%#lx, error=%d\n", addr, SLMError );
472 #endif
473
474         wake_up( &print_wait );
475         stdma_release();
476         ENABLE_IRQ();
477         return IRQ_HANDLED;
478 }
479
480
481 static void slm_test_ready( unsigned long dummy )
482
483 {
484 #ifdef SLM_CONT_CNT_REPROG
485         /* program for 255*512 bytes again */
486         dma_wd.fdc_acces_seccount = SLM_DMA_AMOUNT;
487         START_TIMER( DMA_TIME_FOR(0) );
488 #ifdef DEBUG
489         printk( "SLM: reprogramming timer for %d jiffies, addr=%#lx\n",
490                         DMA_TIME_FOR(0), get_dma_addr() );
491 #endif
492         
493 #else /* !SLM_CONT_CNT_REPROG */
494
495         unsigned long   flags, addr;
496         int                             d, ti;
497 #ifdef DEBUG
498         struct timeval start_tm, end_tm;
499         int                        did_wait = 0;
500 #endif
501
502         local_irq_save(flags);
503
504         addr = get_dma_addr();
505         if ((d = SLMEndAddr - addr) > 0) {
506                 local_irq_restore(flags);
507                 
508                 /* slice not yet finished, decide whether to start another timer or to
509                  * busy-wait */
510                 ti = DMA_TIME_FOR( d );
511                 if (ti > 0) {
512 #ifdef DEBUG
513                         printk( "SLM: reprogramming timer for %d jiffies, rest %d bytes\n",
514                                         ti, d );
515 #endif
516                         START_TIMER( ti );
517                         return;
518                 }
519                 /* wait for desired end address to be reached */
520 #ifdef DEBUG
521                 do_gettimeofday( &start_tm );
522                 did_wait = 1;
523 #endif
524                 local_irq_disable();
525                 while( get_dma_addr() < SLMEndAddr )
526                         barrier();
527         }
528
529         /* slice finished, start next one */
530         SLMCurAddr += SLMSliceSize;
531
532 #ifdef SLM_CONTINUOUS_DMA
533         /* program for 255*512 bytes again */
534         dma_wd.fdc_acces_seccount = SLM_DMA_AMOUNT;
535 #else
536         /* set DMA address;
537          * add 2 bytes for the ones in the SLM controller FIFO! */
538         set_dma_addr( SLMCurAddr + 2 );
539         /* toggle DMA to write and select sector counter reg */
540         dma_wd.dma_mode_status = 0x92;
541         MFPDELAY();
542         dma_wd.dma_mode_status = 0x192;
543         MFPDELAY();
544         /* program for 255*512 bytes and start DMA */
545         DMA_LONG_WRITE( SLM_DMA_AMOUNT, 0x112 );
546 #endif
547         
548         local_irq_restore(flags);
549
550 #ifdef DEBUG
551         if (did_wait) {
552                 int ms;
553                 do_gettimeofday( &end_tm );
554                 ms = (end_tm.tv_sec*1000000+end_tm.tv_usec) -
555                          (start_tm.tv_sec*1000000+start_tm.tv_usec); 
556                 printk( "SLM: did %ld.%ld ms busy waiting for %d bytes\n",
557                                 ms/1000, ms%1000, d );
558         }
559         else
560                 printk( "SLM: didn't wait (!)\n" );
561 #endif
562
563         if ((unsigned char *)PTOV( SLMCurAddr + SLMSliceSize ) >= BufferP) {
564                 /* will be last slice, no timer necessary */
565 #ifdef DEBUG
566                 printk( "SLM: CurAddr=%#lx EndAddr=%#lx last slice -> no timer\n",
567                                 SLMCurAddr, SLMEndAddr );
568 #endif
569         }
570         else {
571                 /* not last slice */
572                 SLMEndAddr = SLMCurAddr + SLMSliceSize + SLM_DMA_INT_OFFSET;
573                 START_TIMER( DMA_TIME_FOR( SLMSliceSize ));
574 #ifdef DEBUG
575                 printk( "SLM: CurAddr=%#lx EndAddr=%#lx timer=%ld\n",
576                                 SLMCurAddr, SLMEndAddr, DMA_TIME_FOR( SLMSliceSize ) );
577 #endif
578         }
579 #endif /* SLM_CONT_CNT_REPROG */
580 }
581
582
583 static void set_dma_addr( unsigned long paddr )
584
585 {       unsigned long flags;
586
587         local_irq_save(flags);
588         dma_wd.dma_lo = (unsigned char)paddr;
589         paddr >>= 8;
590         MFPDELAY();
591         dma_wd.dma_md = (unsigned char)paddr;
592         paddr >>= 8;
593         MFPDELAY();
594         if (ATARIHW_PRESENT( EXTD_DMA ))
595                 st_dma_ext_dmahi = (unsigned short)paddr;
596         else
597                 dma_wd.dma_hi = (unsigned char)paddr;
598         MFPDELAY();
599         local_irq_restore(flags);
600 }
601
602
603 static unsigned long get_dma_addr( void )
604
605 {       unsigned long   addr;
606         
607         addr = dma_wd.dma_lo & 0xff;
608         MFPDELAY();
609         addr |= (dma_wd.dma_md & 0xff) << 8;
610         MFPDELAY();
611         addr |= (dma_wd.dma_hi & 0xff) << 16;
612         MFPDELAY();
613
614         return( addr );
615 }
616
617
618 static ssize_t slm_write( struct file *file, const char *buf, size_t count,
619                                                   loff_t *ppos )
620
621 {
622         struct inode *node = file->f_dentry->d_inode;
623         int             device = iminor(node);
624         int             n, filled, w, h;
625
626         while( SLMState == PRINTING ||
627                    (SLMState == FILLING && SLMBufOwner != device) ) {
628                 interruptible_sleep_on( &slm_wait );
629                 if (signal_pending(current))
630                         return( -ERESTARTSYS );
631         }
632         if (SLMState == IDLE) {
633                 /* first data of page: get current page size  */
634                 if (slm_get_pagesize( device, &w, &h ))
635                         return( -EIO );
636                 BufferSize = w*h/8;
637                 if (BufferSize > SLM_BUFFER_SIZE)
638                         return( -ENOMEM );
639
640                 SLMState = FILLING;
641                 SLMBufOwner = device;
642         }
643
644         n = count;
645         filled = BufferP - SLMBuffer;
646         if (filled + n > BufferSize)
647                 n = BufferSize - filled;
648
649         if (copy_from_user(BufferP, buf, n))
650                 return -EFAULT;
651         BufferP += n;
652         filled += n;
653
654         if (filled == BufferSize) {
655                 /* Check the paper size again! The user may have switched it in the
656                  * time between starting the data and finishing them. Would end up in
657                  * a trashy page... */
658                 if (slm_get_pagesize( device, &w, &h ))
659                         return( -EIO );
660                 if (BufferSize != w*h/8) {
661                         printk( KERN_NOTICE "slm%d: page size changed while printing\n",
662                                         device );
663                         return( -EAGAIN );
664                 }
665
666                 SLMState = PRINTING;
667                 /* choose a slice size that is a multiple of the line size */
668 #ifndef SLM_CONT_CNT_REPROG
669                 SLMSliceSize = SLM_SLICE_SIZE(w);
670 #endif
671                 
672                 start_print( device );
673                 sleep_on( &print_wait );
674                 if (SLMError && IS_REAL_ERROR(SLMError)) {
675                         printk( KERN_ERR "slm%d: %s\n", device, slm_errstr(SLMError) );
676                         n = -EIO;
677                 }
678
679                 SLMState = IDLE;
680                 BufferP = SLMBuffer;
681                 wake_up_interruptible( &slm_wait );
682         }
683         
684         return( n );
685 }
686
687
688 /* ---------------------------------------------------------------------- */
689 /*                                                         ioctl Functions                                                        */
690
691
692 static int slm_ioctl( struct inode *inode, struct file *file,
693                                           unsigned int cmd, unsigned long arg )
694
695 {       int             device = iminor(inode), err;
696         
697         /* I can think of setting:
698          *  - manual feed
699          *  - paper format
700          *  - copy count
701          *  - ...
702          * but haven't implemented that yet :-)
703          * BTW, has anybody better docs about the MODE SENSE/MODE SELECT data?
704          */
705         switch( cmd ) {
706
707           case SLMIORESET:              /* reset buffer, i.e. empty the buffer */
708                 if (!(file->f_mode & 2))
709                         return( -EINVAL );
710                 if (SLMState == PRINTING)
711                         return( -EBUSY );
712                 SLMState = IDLE;
713                 BufferP = SLMBuffer;
714                 wake_up_interruptible( &slm_wait );
715                 return( 0 );
716                 
717           case SLMIOGSTAT: {    /* get status */
718                 int stat;
719                 char *str;
720
721                 stat = slm_req_sense( device );
722                 if (arg) {
723                         str = slm_errstr( stat );
724                         if (put_user(stat,
725                                      (long *)&((struct SLM_status *)arg)->stat))
726                                 return -EFAULT;
727                         if (copy_to_user( ((struct SLM_status *)arg)->str, str,
728                                                  strlen(str) + 1))
729                                 return -EFAULT;
730                 }
731                 return( stat );
732           }
733                 
734           case SLMIOGPSIZE: {   /* get paper size */
735                 int w, h;
736                 
737                 if ((err = slm_get_pagesize( device, &w, &h ))) return( err );
738                 
739                 if (put_user(w, (long *)&((struct SLM_paper_size *)arg)->width))
740                         return -EFAULT;
741                 if (put_user(h, (long *)&((struct SLM_paper_size *)arg)->height))
742                         return -EFAULT;
743                 return( 0 );
744           }
745                 
746           case SLMIOGMFEED:     /* get manual feed */
747                 return( -EINVAL );
748
749           case SLMIOSPSIZE:     /* set paper size */
750                 return( -EINVAL );
751
752           case SLMIOSMFEED:     /* set manual feed */
753                 return( -EINVAL );
754
755         }
756         return( -EINVAL );
757 }
758
759
760 /* ---------------------------------------------------------------------- */
761 /*                                                       Opening and Closing                                              */
762
763
764 static int slm_open( struct inode *inode, struct file *file )
765
766 {       int device;
767         struct slm *sip;
768         
769         device = iminor(inode);
770         if (device >= N_SLM_Printers)
771                 return( -ENXIO );
772         sip = &slm_info[device];
773
774         if (file->f_mode & 2) {
775                 /* open for writing is exclusive */
776                 if ( !atomic_dec_and_test(&sip->wr_ok) ) {
777                         atomic_inc(&sip->wr_ok);        
778                         return( -EBUSY );
779                 }
780         }
781         if (file->f_mode & 1) {
782                 /* open for reading is exclusive */
783                 if ( !atomic_dec_and_test(&sip->rd_ok) ) {
784                         atomic_inc(&sip->rd_ok);
785                         return( -EBUSY );
786                 }
787         }
788
789         return( 0 );
790 }
791
792
793 static int slm_release( struct inode *inode, struct file *file )
794
795 {       int device;
796         struct slm *sip;
797         
798         device = iminor(inode);
799         sip = &slm_info[device];
800
801         if (file->f_mode & 2)
802                 atomic_inc( &sip->wr_ok );
803         if (file->f_mode & 1)
804                 atomic_inc( &sip->rd_ok );
805         
806         return( 0 );
807 }
808
809
810 /* ---------------------------------------------------------------------- */
811 /*                                               ACSI Primitives for the SLM                                      */
812
813
814 static int slm_req_sense( int device )
815
816 {       int                     stat, rv;
817         struct slm *sip = &slm_info[device];
818         
819         stdma_lock( NULL, NULL );
820
821         CMDSET_TARG_LUN( slmreqsense_cmd, sip->target, sip->lun );
822         if (!acsicmd_nodma( slmreqsense_cmd, 0 ) ||
823                 (stat = acsi_getstatus()) < 0)
824                 rv = SLMSTAT_ACSITO;
825         else
826                 rv = stat & 0x1f;
827
828         ENABLE_IRQ();
829         stdma_release();
830         return( rv );
831 }
832
833
834 static int slm_mode_sense( int device, char *buffer, int abs_flag )
835
836 {       unsigned char   stat, len;
837         int                             rv = 0;
838         struct slm              *sip = &slm_info[device];
839         
840         stdma_lock( NULL, NULL );
841
842         CMDSET_TARG_LUN( slmmsense_cmd, sip->target, sip->lun );
843         slmmsense_cmd[5] = abs_flag ? 0x80 : 0;
844         if (!acsicmd_nodma( slmmsense_cmd, 0 )) {
845                 rv = SLMSTAT_ACSITO;
846                 goto the_end;
847         }
848
849         if (!acsi_extstatus( &stat, 1 )) {
850                 acsi_end_extstatus();
851                 rv = SLMSTAT_ACSITO;
852                 goto the_end;
853         }
854         
855         if (!acsi_extstatus( &len, 1 )) {
856                 acsi_end_extstatus();
857                 rv = SLMSTAT_ACSITO;
858                 goto the_end;
859         }
860         buffer[0] = len;
861         if (!acsi_extstatus( buffer+1, len )) {
862                 acsi_end_extstatus();
863                 rv = SLMSTAT_ACSITO;
864                 goto the_end;
865         }
866         
867         acsi_end_extstatus();
868         rv = stat & 0x1f;
869
870   the_end:
871         ENABLE_IRQ();
872         stdma_release();
873         return( rv );
874 }
875
876
877 #if 0
878 /* currently unused */
879 static int slm_mode_select( int device, char *buffer, int len,
880                                                         int default_flag )
881
882 {       int                     stat, rv;
883         struct slm      *sip = &slm_info[device];
884         
885         stdma_lock( NULL, NULL );
886
887         CMDSET_TARG_LUN( slmmselect_cmd, sip->target, sip->lun );
888         slmmselect_cmd[5] = default_flag ? 0x80 : 0;
889         if (!acsicmd_nodma( slmmselect_cmd, 0 )) {
890                 rv = SLMSTAT_ACSITO;
891                 goto the_end;
892         }
893
894         if (!default_flag) {
895                 unsigned char c = len;
896                 if (!acsi_extcmd( &c, 1 )) {
897                         rv = SLMSTAT_ACSITO;
898                         goto the_end;
899                 }
900                 if (!acsi_extcmd( buffer, len )) {
901                         rv = SLMSTAT_ACSITO;
902                         goto the_end;
903                 }
904         }
905         
906         stat = acsi_getstatus();
907         rv = (stat < 0 ? SLMSTAT_ACSITO : stat);
908
909   the_end:
910         ENABLE_IRQ();
911         stdma_release();
912         return( rv );
913 }
914 #endif
915
916
917 static int slm_get_pagesize( int device, int *w, int *h )
918
919 {       char    buf[256];
920         int             stat;
921         
922         stat = slm_mode_sense( device, buf, 0 );
923         ENABLE_IRQ();
924         stdma_release();
925
926         if (stat != SLMSTAT_OK)
927                 return( -EIO );
928
929         *w = (buf[3] << 8) | buf[4];
930         *h = (buf[1] << 8) | buf[2];
931         return( 0 );
932 }
933
934
935 /* ---------------------------------------------------------------------- */
936 /*                                                              Initialization                                                    */
937
938
939 int attach_slm( int target, int lun )
940
941 {       static int      did_register;
942         int                     len;
943
944         if (N_SLM_Printers >= MAX_SLM) {
945                 printk( KERN_WARNING "Too much SLMs\n" );
946                 return( 0 );
947         }
948         
949         /* do an INQUIRY */
950         udelay(100);
951         CMDSET_TARG_LUN( slminquiry_cmd, target, lun );
952         if (!acsicmd_nodma( slminquiry_cmd, 0 )) {
953           inq_timeout:
954                 printk( KERN_ERR "SLM inquiry command timed out.\n" );
955           inq_fail:
956                 acsi_end_extstatus();
957                 return( 0 );
958         }
959         /* read status and header of return data */
960         if (!acsi_extstatus( SLMBuffer, 6 ))
961                 goto inq_timeout;
962
963         if (SLMBuffer[1] != 2) { /* device type == printer? */
964                 printk( KERN_ERR "SLM inquiry returned device type != printer\n" );
965                 goto inq_fail;
966         }
967         len = SLMBuffer[5];
968         
969         /* read id string */
970         if (!acsi_extstatus( SLMBuffer, len ))
971                 goto inq_timeout;
972         acsi_end_extstatus();
973         SLMBuffer[len] = 0;
974
975         if (!did_register) {
976                 did_register = 1;
977         }
978
979         slm_info[N_SLM_Printers].target = target;
980         slm_info[N_SLM_Printers].lun    = lun;
981         atomic_set(&slm_info[N_SLM_Printers].wr_ok, 1 ); 
982         atomic_set(&slm_info[N_SLM_Printers].rd_ok, 1 );
983         
984         printk( KERN_INFO "  Printer: %s\n", SLMBuffer );
985         printk( KERN_INFO "Detected slm%d at id %d lun %d\n",
986                         N_SLM_Printers, target, lun );
987         N_SLM_Printers++;
988         return( 1 );
989 }
990
991 int slm_init( void )
992
993 {
994         int i;
995         if (register_chrdev( ACSI_MAJOR, "slm", &slm_fops )) {
996                 printk( KERN_ERR "Unable to get major %d for ACSI SLM\n", ACSI_MAJOR );
997                 return -EBUSY;
998         }
999         
1000         if (!(SLMBuffer = atari_stram_alloc( SLM_BUFFER_SIZE, "SLM" ))) {
1001                 printk( KERN_ERR "Unable to get SLM ST-Ram buffer.\n" );
1002                 unregister_chrdev( ACSI_MAJOR, "slm" );
1003                 return -ENOMEM;
1004         }
1005         BufferP = SLMBuffer;
1006         SLMState = IDLE;
1007         
1008         devfs_mk_dir("slm");
1009         for (i = 0; i < MAX_SLM; i++) {
1010                 devfs_mk_cdev(MKDEV(ACSI_MAJOR, i),
1011                                 S_IFCHR|S_IRUSR|S_IWUSR, "slm/%d", i);
1012         }
1013         return 0;
1014 }
1015
1016 #ifdef MODULE
1017
1018 /* from acsi.c */
1019 void acsi_attach_SLMs( int (*attach_func)( int, int ) );
1020
1021 int init_module(void)
1022 {
1023         int err;
1024
1025         if ((err = slm_init()))
1026                 return( err );
1027         /* This calls attach_slm() for every target/lun where acsi.c detected a
1028          * printer */
1029         acsi_attach_SLMs( attach_slm );
1030         return( 0 );
1031 }
1032
1033 void cleanup_module(void)
1034 {
1035         int i;
1036         for (i = 0; i < MAX_SLM; i++)
1037                 devfs_remove("slm/%d", i);
1038         devfs_remove("slm");
1039         if (unregister_chrdev( ACSI_MAJOR, "slm" ) != 0)
1040                 printk( KERN_ERR "acsi_slm: cleanup_module failed\n");
1041         atari_stram_free( SLMBuffer );
1042 }
1043 #endif