?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ALSA] hda-intel - Add support of ATI SB600
[linux-2.6.22.y-op.git] / drivers / block / acsi_slm.c
blob4cb9c13362874cedbed44c24a2982046d1e74e4c
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
linux v2.6.22.y-op