sb1250-mac.c: De-typedef, de-volatile, de-etc...
[linux-2.6] / drivers / block / paride / ppc6lnx.c
1 /*
2         ppc6lnx.c (c) 2001 Micro Solutions Inc.
3                 Released under the terms of the GNU General Public license
4
5         ppc6lnx.c  is a par of the protocol driver for the Micro Solutions
6                 "BACKPACK" parallel port IDE adapter
7                 (Works on Series 6 drives)
8
9 */
10
11 //***************************************************************************
12
13 // PPC 6 Code in C sanitized for LINUX
14 // Original x86 ASM by Ron, Converted to C by Clive
15
16 //***************************************************************************
17
18
19 #define port_stb                                        1
20 #define port_afd                                        2
21 #define cmd_stb                                         port_afd
22 #define port_init                                       4
23 #define data_stb                                        port_init
24 #define port_sel                                        8
25 #define port_int                                        16
26 #define port_dir                                        0x20
27
28 #define ECR_EPP 0x80
29 #define ECR_BI  0x20
30
31 //***************************************************************************
32
33 //  60772 Commands
34
35 #define ACCESS_REG                              0x00
36 #define ACCESS_PORT                             0x40
37
38 #define ACCESS_READ                             0x00
39 #define ACCESS_WRITE                    0x20
40
41 //  60772 Command Prefix
42
43 #define CMD_PREFIX_SET          0xe0            // Special command that modifies the next command's operation
44 #define CMD_PREFIX_RESET        0xc0            // Resets current cmd modifier reg bits
45  #define PREFIX_IO16                    0x01            // perform 16-bit wide I/O
46  #define PREFIX_FASTWR          0x04            // enable PPC mode fast-write
47  #define PREFIX_BLK                             0x08            // enable block transfer mode
48
49 // 60772 Registers
50
51 #define REG_STATUS                              0x00            // status register
52  #define STATUS_IRQA                    0x01            // Peripheral IRQA line
53  #define STATUS_EEPROM_DO       0x40            // Serial EEPROM data bit
54 #define REG_VERSION                             0x01            // PPC version register (read)
55 #define REG_HWCFG                                       0x02            // Hardware Config register
56 #define REG_RAMSIZE                             0x03            // Size of RAM Buffer
57  #define RAMSIZE_128K                   0x02
58 #define REG_EEPROM                              0x06            // EEPROM control register
59  #define EEPROM_SK                              0x01            // eeprom SK bit
60  #define EEPROM_DI                              0x02            // eeprom DI bit
61  #define EEPROM_CS                              0x04            // eeprom CS bit
62  #define EEPROM_EN                              0x08            // eeprom output enable
63 #define REG_BLKSIZE                             0x08            // Block transfer len (24 bit)
64
65 //***************************************************************************
66
67 typedef struct ppc_storage {
68         u16     lpt_addr;                               // LPT base address
69         u8      ppc_id;
70         u8      mode;                                           // operating mode
71                                         // 0 = PPC Uni SW
72                                         // 1 = PPC Uni FW
73                                         // 2 = PPC Bi SW
74                                         // 3 = PPC Bi FW
75                                         // 4 = EPP Byte
76                                         // 5 = EPP Word
77                                         // 6 = EPP Dword
78         u8      ppc_flags;
79         u8      org_data;                               // original LPT data port contents
80         u8      org_ctrl;                               // original LPT control port contents
81         u8      cur_ctrl;                               // current control port contents
82 } Interface;
83
84 //***************************************************************************
85
86 // ppc_flags
87
88 #define fifo_wait                                       0x10
89
90 //***************************************************************************
91
92 // DONT CHANGE THESE LEST YOU BREAK EVERYTHING - BIT FIELD DEPENDENCIES
93
94 #define PPCMODE_UNI_SW          0
95 #define PPCMODE_UNI_FW          1
96 #define PPCMODE_BI_SW                   2
97 #define PPCMODE_BI_FW                   3
98 #define PPCMODE_EPP_BYTE        4
99 #define PPCMODE_EPP_WORD        5
100 #define PPCMODE_EPP_DWORD       6
101
102 //***************************************************************************
103
104 static int ppc6_select(Interface *ppc);
105 static void ppc6_deselect(Interface *ppc);
106 static void ppc6_send_cmd(Interface *ppc, u8 cmd);
107 static void ppc6_wr_data_byte(Interface *ppc, u8 data);
108 static u8 ppc6_rd_data_byte(Interface *ppc);
109 static u8 ppc6_rd_port(Interface *ppc, u8 port);
110 static void ppc6_wr_port(Interface *ppc, u8 port, u8 data);
111 static void ppc6_rd_data_blk(Interface *ppc, u8 *data, long count);
112 static void ppc6_wait_for_fifo(Interface *ppc);
113 static void ppc6_wr_data_blk(Interface *ppc, u8 *data, long count);
114 static void ppc6_rd_port16_blk(Interface *ppc, u8 port, u8 *data, long length);
115 static void ppc6_wr_port16_blk(Interface *ppc, u8 port, u8 *data, long length);
116 static void ppc6_wr_extout(Interface *ppc, u8 regdata);
117 static int ppc6_open(Interface *ppc);
118 static void ppc6_close(Interface *ppc);
119
120 //***************************************************************************
121
122 static int ppc6_select(Interface *ppc)
123 {
124         u8 i, j, k;
125
126         i = inb(ppc->lpt_addr + 1);
127
128         if (i & 1)
129                 outb(i, ppc->lpt_addr + 1);
130
131         ppc->org_data = inb(ppc->lpt_addr);
132
133         ppc->org_ctrl = inb(ppc->lpt_addr + 2) & 0x5F; // readback ctrl
134
135         ppc->cur_ctrl = ppc->org_ctrl;
136
137         ppc->cur_ctrl |= port_sel;
138
139         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
140
141         if (ppc->org_data == 'b')
142                 outb('x', ppc->lpt_addr);
143
144         outb('b', ppc->lpt_addr);
145         outb('p', ppc->lpt_addr);
146         outb(ppc->ppc_id, ppc->lpt_addr);
147         outb(~ppc->ppc_id,ppc->lpt_addr);
148
149         ppc->cur_ctrl &= ~port_sel;
150
151         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
152
153         ppc->cur_ctrl = (ppc->cur_ctrl & port_int) | port_init;
154
155         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
156
157         i = ppc->mode & 0x0C;
158
159         if (i == 0)
160                 i = (ppc->mode & 2) | 1;
161
162         outb(i, ppc->lpt_addr);
163
164         ppc->cur_ctrl |= port_sel;
165
166         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
167
168         // DELAY
169
170         ppc->cur_ctrl |= port_afd;
171
172         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
173
174         j = ((i & 0x08) << 4) | ((i & 0x07) << 3);
175
176         k = inb(ppc->lpt_addr + 1) & 0xB8;
177
178         if (j == k)
179         {
180                 ppc->cur_ctrl &= ~port_afd;
181
182                 outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
183
184                 k = (inb(ppc->lpt_addr + 1) & 0xB8) ^ 0xB8;
185
186                 if (j == k)
187                 {
188                         if (i & 4)      // EPP
189                                 ppc->cur_ctrl &= ~(port_sel | port_init);
190                         else                            // PPC/ECP
191                                 ppc->cur_ctrl &= ~port_sel;
192
193                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
194
195                         return(1);
196                 }
197         }
198
199         outb(ppc->org_ctrl, ppc->lpt_addr + 2);
200
201         outb(ppc->org_data, ppc->lpt_addr);
202
203         return(0); // FAIL
204 }
205
206 //***************************************************************************
207
208 static void ppc6_deselect(Interface *ppc)
209 {
210         if (ppc->mode & 4)      // EPP
211                 ppc->cur_ctrl |= port_init;
212         else                                                            // PPC/ECP
213                 ppc->cur_ctrl |= port_sel;
214
215         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
216
217         outb(ppc->org_data, ppc->lpt_addr);
218
219         outb((ppc->org_ctrl | port_sel), ppc->lpt_addr + 2);
220
221         outb(ppc->org_ctrl, ppc->lpt_addr + 2);
222 }
223
224 //***************************************************************************
225
226 static void ppc6_send_cmd(Interface *ppc, u8 cmd)
227 {
228         switch(ppc->mode)
229         {
230                 case PPCMODE_UNI_SW :
231                 case PPCMODE_UNI_FW :
232                 case PPCMODE_BI_SW :
233                 case PPCMODE_BI_FW :
234                 {
235                         outb(cmd, ppc->lpt_addr);
236
237                         ppc->cur_ctrl ^= cmd_stb;
238
239                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
240
241                         break;
242                 }
243
244                 case PPCMODE_EPP_BYTE :
245                 case PPCMODE_EPP_WORD :
246                 case PPCMODE_EPP_DWORD :
247                 {
248                         outb(cmd, ppc->lpt_addr + 3);
249
250                         break;
251                 }
252         }
253 }
254
255 //***************************************************************************
256
257 static void ppc6_wr_data_byte(Interface *ppc, u8 data)
258 {
259         switch(ppc->mode)
260         {
261                 case PPCMODE_UNI_SW :
262                 case PPCMODE_UNI_FW :
263                 case PPCMODE_BI_SW :
264                 case PPCMODE_BI_FW :
265                 {
266                         outb(data, ppc->lpt_addr);
267
268                         ppc->cur_ctrl ^= data_stb;
269
270                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
271
272                         break;
273                 }
274
275                 case PPCMODE_EPP_BYTE :
276                 case PPCMODE_EPP_WORD :
277                 case PPCMODE_EPP_DWORD :
278                 {
279                         outb(data, ppc->lpt_addr + 4);
280
281                         break;
282                 }
283         }
284 }
285
286 //***************************************************************************
287
288 static u8 ppc6_rd_data_byte(Interface *ppc)
289 {
290         u8 data = 0;
291
292         switch(ppc->mode)
293         {
294                 case PPCMODE_UNI_SW :
295                 case PPCMODE_UNI_FW :
296                 {
297                         ppc->cur_ctrl = (ppc->cur_ctrl & ~port_stb) ^ data_stb;
298
299                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
300
301                         // DELAY
302
303                         data = inb(ppc->lpt_addr + 1);
304
305                         data = ((data & 0x80) >> 1) | ((data & 0x38) >> 3);
306
307                         ppc->cur_ctrl |= port_stb;
308
309                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
310
311                         // DELAY
312
313                         data |= inb(ppc->lpt_addr + 1) & 0xB8;
314
315                         break;
316                 }
317
318                 case PPCMODE_BI_SW :
319                 case PPCMODE_BI_FW :
320                 {
321                         ppc->cur_ctrl |= port_dir;
322
323                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
324
325                         ppc->cur_ctrl = (ppc->cur_ctrl | port_stb) ^ data_stb;
326
327                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
328
329                         data = inb(ppc->lpt_addr);
330
331                         ppc->cur_ctrl &= ~port_stb;
332
333                         outb(ppc->cur_ctrl,ppc->lpt_addr + 2);
334
335                         ppc->cur_ctrl &= ~port_dir;
336
337                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
338
339                         break;
340                 }
341
342                 case PPCMODE_EPP_BYTE :
343                 case PPCMODE_EPP_WORD :
344                 case PPCMODE_EPP_DWORD :
345                 {
346                         outb((ppc->cur_ctrl | port_dir),ppc->lpt_addr + 2);
347
348                         data = inb(ppc->lpt_addr + 4);
349
350                         outb(ppc->cur_ctrl,ppc->lpt_addr + 2);
351
352                         break;
353                 }
354         }
355
356         return(data);
357 }
358
359 //***************************************************************************
360
361 static u8 ppc6_rd_port(Interface *ppc, u8 port)
362 {
363         ppc6_send_cmd(ppc,(u8)(port | ACCESS_PORT | ACCESS_READ));
364
365         return(ppc6_rd_data_byte(ppc));
366 }
367
368 //***************************************************************************
369
370 static void ppc6_wr_port(Interface *ppc, u8 port, u8 data)
371 {
372         ppc6_send_cmd(ppc,(u8)(port | ACCESS_PORT | ACCESS_WRITE));
373
374         ppc6_wr_data_byte(ppc, data);
375 }
376
377 //***************************************************************************
378
379 static void ppc6_rd_data_blk(Interface *ppc, u8 *data, long count)
380 {
381         switch(ppc->mode)
382         {
383                 case PPCMODE_UNI_SW :
384                 case PPCMODE_UNI_FW :
385                 {
386                         while(count)
387                         {
388                                 u8 d;
389
390                                 ppc->cur_ctrl = (ppc->cur_ctrl & ~port_stb) ^ data_stb;
391
392                                 outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
393
394                                 // DELAY
395
396                                 d = inb(ppc->lpt_addr + 1);
397
398                                 d = ((d & 0x80) >> 1) | ((d & 0x38) >> 3);
399
400                                 ppc->cur_ctrl |= port_stb;
401
402                                 outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
403
404                                 // DELAY
405
406                                 d |= inb(ppc->lpt_addr + 1) & 0xB8;
407
408                                 *data++ = d;
409                                 count--;
410                         }
411
412                         break;
413                 }
414
415                 case PPCMODE_BI_SW :
416                 case PPCMODE_BI_FW :
417                 {
418                         ppc->cur_ctrl |= port_dir;
419
420                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
421
422                         ppc->cur_ctrl |= port_stb;
423
424                         while(count)
425                         {
426                                 ppc->cur_ctrl ^= data_stb;
427
428                                 outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
429
430                                 *data++ = inb(ppc->lpt_addr);
431                                 count--;
432                         }
433
434                         ppc->cur_ctrl &= ~port_stb;
435
436                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
437
438                         ppc->cur_ctrl &= ~port_dir;
439
440                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
441
442                         break;
443                 }
444
445                 case PPCMODE_EPP_BYTE :
446                 {
447                         outb((ppc->cur_ctrl | port_dir), ppc->lpt_addr + 2);
448
449                         // DELAY
450
451                         while(count)
452                         {
453                                 *data++ = inb(ppc->lpt_addr + 4);
454                                 count--;
455                         }
456
457                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
458
459                         break;
460                 }
461
462                 case PPCMODE_EPP_WORD :
463                 {
464                         outb((ppc->cur_ctrl | port_dir), ppc->lpt_addr + 2);
465
466                         // DELAY
467
468                         while(count > 1)
469                         {
470                                 *((u16 *)data) = inw(ppc->lpt_addr + 4);
471                                 data  += 2;
472                                 count -= 2;
473                         }
474
475                         while(count)
476                         {
477                                 *data++ = inb(ppc->lpt_addr + 4);
478                                 count--;
479                         }
480
481                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
482
483                         break;
484                 }
485
486                 case PPCMODE_EPP_DWORD :
487                 {
488                         outb((ppc->cur_ctrl | port_dir),ppc->lpt_addr + 2);
489
490                         // DELAY
491
492                         while(count > 3)
493                         {
494                                 *((u32 *)data) = inl(ppc->lpt_addr + 4);
495                                 data  += 4;
496                                 count -= 4;
497                         }
498
499                         while(count)
500                         {
501                                 *data++ = inb(ppc->lpt_addr + 4);
502                                 count--;
503                         }
504
505                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
506
507                         break;
508                 }
509         }
510
511 }
512
513 //***************************************************************************
514
515 static void ppc6_wait_for_fifo(Interface *ppc)
516 {
517         int i;
518
519         if (ppc->ppc_flags & fifo_wait)
520         {
521                 for(i=0; i<20; i++)
522                         inb(ppc->lpt_addr + 1);
523         }
524 }
525
526 //***************************************************************************
527
528 static void ppc6_wr_data_blk(Interface *ppc, u8 *data, long count)
529 {
530         switch(ppc->mode)
531         {
532                 case PPCMODE_UNI_SW :
533                 case PPCMODE_BI_SW :
534                 {
535                         while(count--)
536                         {
537                                 outb(*data++, ppc->lpt_addr);
538
539                                 ppc->cur_ctrl ^= data_stb;
540
541                                 outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
542                         }
543
544                         break;
545                 }
546
547                 case PPCMODE_UNI_FW :
548                 case PPCMODE_BI_FW :
549                 {
550                         u8 this, last;
551
552                         ppc6_send_cmd(ppc,(CMD_PREFIX_SET | PREFIX_FASTWR));
553
554                         ppc->cur_ctrl |= port_stb;
555
556                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
557
558                         last = *data;
559
560                         outb(last, ppc->lpt_addr);
561
562                         while(count)
563                         {
564                                 this = *data++;
565                                 count--;
566
567                                 if (this == last)
568                                 {
569                                         ppc->cur_ctrl ^= data_stb;
570
571                                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
572                                 }
573                                 else
574                                 {
575                                         outb(this, ppc->lpt_addr);
576
577                                         last = this;
578                                 }
579                         }
580
581                         ppc->cur_ctrl &= ~port_stb;
582
583                         outb(ppc->cur_ctrl, ppc->lpt_addr + 2);
584
585                         ppc6_send_cmd(ppc,(CMD_PREFIX_RESET | PREFIX_FASTWR));
586
587                         break;
588                 }
589
590                 case PPCMODE_EPP_BYTE :
591                 {
592                         while(count)
593                         {
594                                 outb(*data++,ppc->lpt_addr + 4);
595                                 count--;
596                         }
597
598                         ppc6_wait_for_fifo(ppc);
599
600                         break;
601                 }
602
603                 case PPCMODE_EPP_WORD :
604                 {
605                         while(count > 1)
606                         {
607                                 outw(*((u16 *)data),ppc->lpt_addr + 4);
608                                 data  += 2;
609                                 count -= 2;
610                         }
611
612                         while(count)
613                         {
614                                 outb(*data++,ppc->lpt_addr + 4);
615                                 count--;
616                         }
617
618                         ppc6_wait_for_fifo(ppc);
619
620                         break;
621                 }
622
623                 case PPCMODE_EPP_DWORD :
624                 {
625                         while(count > 3)
626                         {
627                                 outl(*((u32 *)data),ppc->lpt_addr + 4);
628                                 data  += 4;
629                                 count -= 4;
630                         }
631
632                         while(count)
633                         {
634                                 outb(*data++,ppc->lpt_addr + 4);
635                                 count--;
636                         }
637
638                         ppc6_wait_for_fifo(ppc);
639
640                         break;
641                 }
642         }
643 }
644
645 //***************************************************************************
646
647 static void ppc6_rd_port16_blk(Interface *ppc, u8 port, u8 *data, long length)
648 {
649         length = length << 1;
650
651         ppc6_send_cmd(ppc, (REG_BLKSIZE | ACCESS_REG | ACCESS_WRITE));
652         ppc6_wr_data_byte(ppc,(u8)length);
653         ppc6_wr_data_byte(ppc,(u8)(length >> 8));
654         ppc6_wr_data_byte(ppc,0);
655
656         ppc6_send_cmd(ppc, (CMD_PREFIX_SET | PREFIX_IO16 | PREFIX_BLK));
657
658         ppc6_send_cmd(ppc, (u8)(port | ACCESS_PORT | ACCESS_READ));
659
660         ppc6_rd_data_blk(ppc, data, length);
661
662         ppc6_send_cmd(ppc, (CMD_PREFIX_RESET | PREFIX_IO16 | PREFIX_BLK));
663 }
664
665 //***************************************************************************
666
667 static void ppc6_wr_port16_blk(Interface *ppc, u8 port, u8 *data, long length)
668 {
669         length = length << 1;
670
671         ppc6_send_cmd(ppc, (REG_BLKSIZE | ACCESS_REG | ACCESS_WRITE));
672         ppc6_wr_data_byte(ppc,(u8)length);
673         ppc6_wr_data_byte(ppc,(u8)(length >> 8));
674         ppc6_wr_data_byte(ppc,0);
675
676         ppc6_send_cmd(ppc, (CMD_PREFIX_SET | PREFIX_IO16 | PREFIX_BLK));
677
678         ppc6_send_cmd(ppc, (u8)(port | ACCESS_PORT | ACCESS_WRITE));
679
680         ppc6_wr_data_blk(ppc, data, length);
681
682         ppc6_send_cmd(ppc, (CMD_PREFIX_RESET | PREFIX_IO16 | PREFIX_BLK));
683 }
684
685 //***************************************************************************
686
687 static void ppc6_wr_extout(Interface *ppc, u8 regdata)
688 {
689         ppc6_send_cmd(ppc,(REG_VERSION | ACCESS_REG | ACCESS_WRITE));
690
691         ppc6_wr_data_byte(ppc, (u8)((regdata & 0x03) << 6));
692 }
693
694 //***************************************************************************
695
696 static int ppc6_open(Interface *ppc)
697 {
698         int ret;
699
700         ret = ppc6_select(ppc);
701
702         if (ret == 0)
703                 return(ret);
704
705         ppc->ppc_flags &= ~fifo_wait;
706
707         ppc6_send_cmd(ppc, (ACCESS_REG | ACCESS_WRITE | REG_RAMSIZE));
708         ppc6_wr_data_byte(ppc, RAMSIZE_128K);
709
710         ppc6_send_cmd(ppc, (ACCESS_REG | ACCESS_READ | REG_VERSION));
711
712         if ((ppc6_rd_data_byte(ppc) & 0x3F) == 0x0C)
713                 ppc->ppc_flags |= fifo_wait;
714
715         return(ret);
716 }
717
718 //***************************************************************************
719
720 static void ppc6_close(Interface *ppc)
721 {
722         ppc6_deselect(ppc);
723 }
724
725 //***************************************************************************
726