friq.c
上传用户:lgb322
上传日期:2013-02-24
资源大小:30529k
文件大小:6k
源码类别:

嵌入式Linux

开发平台:

Unix_Linux

  1. /* 
  2. friq.c (c) 1998    Grant R. Guenther <grant@torque.net>
  3.             Under the terms of the GNU General Public License
  4. friq.c is a low-level protocol driver for the Freecom "IQ"
  5. parallel port IDE adapter.   Early versions of this adapter
  6. use the 'frpw' protocol.
  7. Freecom uses this adapter in a battery powered external 
  8. CD-ROM drive.  It is also used in LS-120 drives by
  9. Maxell and Panasonic, and other devices.
  10. The battery powered drive requires software support to
  11. control the power to the drive.  This module enables the
  12. drive power when the high level driver (pcd) is loaded
  13. and disables it when the module is unloaded.  Note, if
  14. the friq module is built in to the kernel, the power
  15. will never be switched off, so other means should be
  16. used to conserve battery power.
  17. */
  18. /* Changes:
  19. 1.01 GRG 1998.12.20  Added support for soft power switch
  20. */
  21. #define FRIQ_VERSION "1.01" 
  22. #include <linux/module.h>
  23. #include <linux/delay.h>
  24. #include <linux/kernel.h>
  25. #include <linux/types.h>
  26. #include <linux/wait.h>
  27. #include <asm/io.h>
  28. #include "paride.h"
  29. #define CMD(x) w2(4);w0(0xff);w0(0xff);w0(0x73);w0(0x73);
  30. w0(0xc9);w0(0xc9);w0(0x26);w0(0x26);w0(x);w0(x);
  31. #define j44(l,h) (((l>>4)&0x0f)|(h&0xf0))
  32. /* cont = 0 - access the IDE register file 
  33.    cont = 1 - access the IDE command set 
  34. */
  35. static int  cont_map[2] = { 0x08, 0x10 };
  36. static int friq_read_regr( PIA *pi, int cont, int regr )
  37. { int h,l,r;
  38. r = regr + cont_map[cont];
  39. CMD(r);
  40. w2(6); l = r1();
  41. w2(4); h = r1();
  42. w2(4); 
  43. return j44(l,h);
  44. }
  45. static void friq_write_regr( PIA *pi, int cont, int regr, int val)
  46. { int r;
  47.         r = regr + cont_map[cont];
  48. CMD(r);
  49. w0(val);
  50. w2(5);w2(7);w2(5);w2(4);
  51. }
  52. static void friq_read_block_int( PIA *pi, char * buf, int count, int regr )
  53. {       int     h, l, k, ph;
  54.         switch(pi->mode) {
  55.         case 0: CMD(regr); 
  56.                 for (k=0;k<count;k++) {
  57.                         w2(6); l = r1();
  58.                         w2(4); h = r1();
  59.                         buf[k] = j44(l,h);
  60.                 }
  61.                 w2(4);
  62.                 break;
  63.         case 1: ph = 2;
  64.                 CMD(regr+0xc0); 
  65.                 w0(0xff);
  66.                 for (k=0;k<count;k++) {
  67.                         w2(0xa4 + ph); 
  68.                         buf[k] = r0();
  69.                         ph = 2 - ph;
  70.                 } 
  71.                 w2(0xac); w2(0xa4); w2(4);
  72.                 break;
  73. case 2: CMD(regr+0x80);
  74. for (k=0;k<count-2;k++) buf[k] = r4();
  75. w2(0xac); w2(0xa4);
  76. buf[count-2] = r4();
  77. buf[count-1] = r4();
  78. w2(4);
  79. break;
  80. case 3: CMD(regr+0x80);
  81.                 for (k=0;k<(count/2)-1;k++) ((u16 *)buf)[k] = r4w();
  82.                 w2(0xac); w2(0xa4);
  83.                 buf[count-2] = r4();
  84.                 buf[count-1] = r4();
  85.                 w2(4);
  86.                 break;
  87. case 4: CMD(regr+0x80);
  88.                 for (k=0;k<(count/4)-1;k++) ((u32 *)buf)[k] = r4l();
  89.                 buf[count-4] = r4();
  90.                 buf[count-3] = r4();
  91.                 w2(0xac); w2(0xa4);
  92.                 buf[count-2] = r4();
  93.                 buf[count-1] = r4();
  94.                 w2(4);
  95.                 break;
  96.         }
  97. }
  98. static void friq_read_block( PIA *pi, char * buf, int count)
  99. { friq_read_block_int(pi,buf,count,0x08);
  100. }
  101. static void friq_write_block( PIA *pi, char * buf, int count )
  102.  
  103. { int k;
  104. switch(pi->mode) {
  105. case 0:
  106. case 1: CMD(8); w2(5);
  107.          for (k=0;k<count;k++) {
  108. w0(buf[k]);
  109. w2(7);w2(5);
  110. }
  111. w2(4);
  112. break;
  113. case 2: CMD(0xc8); w2(5);
  114. for (k=0;k<count;k++) w4(buf[k]);
  115. w2(4);
  116. break;
  117.         case 3: CMD(0xc8); w2(5);
  118.                 for (k=0;k<count/2;k++) w4w(((u16 *)buf)[k]);
  119.                 w2(4);
  120.                 break;
  121.         case 4: CMD(0xc8); w2(5);
  122.                 for (k=0;k<count/4;k++) w4l(((u32 *)buf)[k]);
  123.                 w2(4);
  124.                 break;
  125. }
  126. }
  127. static void friq_connect ( PIA *pi  )
  128. {       pi->saved_r0 = r0();
  129.         pi->saved_r2 = r2();
  130. w2(4);
  131. }
  132. static void friq_disconnect ( PIA *pi )
  133. {       CMD(0x20);
  134. w0(pi->saved_r0);
  135.         w2(pi->saved_r2);
  136. static int friq_test_proto( PIA *pi, char * scratch, int verbose )
  137. {       int     j, k, r;
  138. int e[2] = {0,0};
  139. pi->saved_r0 = r0();
  140. w0(0xff); udelay(20); CMD(0x3d); /* turn the power on */
  141. udelay(500);
  142. w0(pi->saved_r0);
  143. friq_connect(pi);
  144. for (j=0;j<2;j++) {
  145.                 friq_write_regr(pi,0,6,0xa0+j*0x10);
  146.                 for (k=0;k<256;k++) {
  147.                         friq_write_regr(pi,0,2,k^0xaa);
  148.                         friq_write_regr(pi,0,3,k^0x55);
  149.                         if (friq_read_regr(pi,0,2) != (k^0xaa)) e[j]++;
  150.                         }
  151.                 }
  152. friq_disconnect(pi);
  153. friq_connect(pi);
  154.         friq_read_block_int(pi,scratch,512,0x10);
  155.         r = 0;
  156.         for (k=0;k<128;k++) if (scratch[k] != k) r++;
  157. friq_disconnect(pi);
  158.         if (verbose)  {
  159.             printk("%s: friq: port 0x%x, mode %d, test=(%d,%d,%d)n",
  160.                    pi->device,pi->port,pi->mode,e[0],e[1],r);
  161.         }
  162.         return (r || (e[0] && e[1]));
  163. }
  164. static void friq_log_adapter( PIA *pi, char * scratch, int verbose )
  165. {       char    *mode_string[6] = {"4-bit","8-bit",
  166.    "EPP-8","EPP-16","EPP-32"};
  167.         printk("%s: friq %s, Freecom IQ ASIC-2 adapter at 0x%x, ", pi->device,
  168. FRIQ_VERSION,pi->port);
  169.         printk("mode %d (%s), delay %dn",pi->mode,
  170. mode_string[pi->mode],pi->delay);
  171. pi->private = 1;
  172. friq_connect(pi);
  173. CMD(0x9e);   /* disable sleep timer */
  174. friq_disconnect(pi);
  175. }
  176. static void friq_init_proto( PIA *pi)
  177. {       MOD_INC_USE_COUNT;
  178. pi->private = 0;
  179. }
  180. static void friq_release_proto( PIA *pi)
  181. {       if (pi->private) { /* turn off the power */
  182. friq_connect(pi);
  183. CMD(0x1d); CMD(0x1e);
  184. friq_disconnect(pi);
  185. pi->private = 0;
  186. }
  187. MOD_DEC_USE_COUNT;
  188. }
  189. struct pi_protocol friq = {"friq",0,5,2,1,1,
  190.                            friq_write_regr,
  191.                            friq_read_regr,
  192.                            friq_write_block,
  193.                            friq_read_block,
  194.                            friq_connect,
  195.                            friq_disconnect,
  196.                            0,
  197.                            0,
  198.                            friq_test_proto,
  199.                            friq_log_adapter,
  200.                            friq_init_proto,
  201.                            friq_release_proto
  202.                           };
  203. #ifdef MODULE
  204. int     init_module(void)
  205. {       return pi_register( &friq ) - 1;
  206. }
  207. void    cleanup_module(void)
  208. {       pi_unregister( &friq );
  209. }
  210. #endif
  211. /* end of friq.c */
  212. MODULE_LICENSE("GPL");