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