开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
bpck.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：9k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

bpck.c：源码内容
  1. /* 
  2. bpck.c (c) 1996-8  Grant R. Guenther <grant@torque.net>
  3.             Under the terms of the GNU General Public License.
  5. bpck.c is a low-level protocol driver for the MicroSolutions 
  6. "backpack" parallel port IDE adapter.  
  8. */
  10. /* Changes:
  12. 1.01 GRG 1998.05.05 init_proto, release_proto, pi->delay 
  13. 1.02    GRG 1998.08.15 default pi->delay returned to 4
  15. */
  17. #define BPCK_VERSION "1.02" 
  19. #include <linux/module.h>
  20. #include <linux/delay.h>
  21. #include <linux/kernel.h>
  22. #include <linux/types.h>
  23. #include <linux/wait.h>
  24. #include <asm/io.h>
  26. #include "paride.h"
  28. #undef r2
  29. #undef w2
  31. #define PC pi->private
  32. #define r2() (PC=(in_p(2) & 0xff))
  33. #define w2(byte)   {out_p(2,byte); PC = byte;}
  34. #define t2(pat)    {PC ^= pat; out_p(2,PC);}
  35. #define e2() {PC &= 0xfe; out_p(2,PC);}
  36. #define o2() {PC |= 1; out_p(2,PC);}
  38. #define j44(l,h)     (((l>>3)&0x7)|((l>>4)&0x8)|((h<<1)&0x70)|(h&0x80))
  40. /* cont = 0 - access the IDE register file 
  41.    cont = 1 - access the IDE command set 
  42.    cont = 2 - use internal bpck register addressing
  43. */
  45. static int  cont_map[3] = { 0x40, 0x48, 0 };
  47. static int bpck_read_regr( PIA *pi, int cont, int regr )
  49. {       int r, l, h;
  51. r = regr + cont_map[cont];
  53. switch (pi->mode) {
  55. case 0: w0(r & 0xf); w0(r); t2(2); t2(4);
  56.         l = r1();
  57.          t2(4);
  58.          h = r1();
  59.          return j44(l,h);
  61. case 1: w0(r & 0xf); w0(r); t2(2);
  62.         e2(); t2(0x20);
  63. t2(4); h = r0();
  64.         t2(1); t2(0x20);
  65.         return h;
  67. case 2:
  68. case 3:
  69. case 4: w0(r); w2(9); w2(0); w2(0x20);
  70. h = r4();
  71. w2(0);
  72. return h;
  74. }
  75. return -1;
  76. }
  78. static void bpck_write_regr( PIA *pi, int cont, int regr, int val )
  80. { int r;
  82.         r = regr + cont_map[cont];
  84. switch (pi->mode) {
  86. case 0:
  87. case 1: w0(r);
  88. t2(2);
  89. w0(val);
  90. o2(); t2(4); t2(1);
  91. break;
  93. case 2:
  94. case 3:
  95. case 4: w0(r); w2(9); w2(0);
  96. w0(val); w2(1); w2(3); w2(0);
  97. break;
  99. }
  100. }
  102. /* These macros access the bpck registers in native addressing */
  104. #define WR(r,v) bpck_write_regr(pi,2,r,v)
  105. #define RR(r) (bpck_read_regr(pi,2,r))
  107. static void bpck_write_block( PIA *pi, char * buf, int count )
  109. { int i;
  111. switch (pi->mode) {
  113. case 0: WR(4,0x40);
  114. w0(0x40); t2(2); t2(1);
  115. for (i=0;i<count;i++) { w0(buf[i]); t2(4); }
  116. WR(4,0);
  117. break;
  119. case 1: WR(4,0x50);
  120.                 w0(0x40); t2(2); t2(1);
  121.                 for (i=0;i<count;i++) { w0(buf[i]); t2(4); }
  122.                 WR(4,0x10);
  123. break;
  125. case 2: WR(4,0x48);
  126. w0(0x40); w2(9); w2(0); w2(1);
  127. for (i=0;i<count;i++) w4(buf[i]);
  128. w2(0);
  129. WR(4,8);
  130. break;
  132.         case 3: WR(4,0x48);
  133.                 w0(0x40); w2(9); w2(0); w2(1);
  134.                 for (i=0;i<count/2;i++) w4w(((u16 *)buf)[i]);
  135.                 w2(0);
  136.                 WR(4,8);
  137.                 break;
  138.  
  139.         case 4: WR(4,0x48);
  140.                 w0(0x40); w2(9); w2(0); w2(1);
  141.                 for (i=0;i<count/4;i++) w4l(((u32 *)buf)[i]);
  142.                 w2(0);
  143.                 WR(4,8);
  144.                 break;
  145.   }
  146. }
  148. static void bpck_read_block( PIA *pi, char * buf, int count )
  150. { int i, l, h;
  152. switch (pi->mode) {
  154.        case 0: WR(4,0x40);
  155. w0(0x40); t2(2);
  156. for (i=0;i<count;i++) {
  157.     t2(4); l = r1();
  158.     t2(4); h = r1();
  159.     buf[i] = j44(l,h);
  160. }
  161. WR(4,0);
  162. break;
  164. case 1: WR(4,0x50);
  165. w0(0x40); t2(2); t2(0x20);
  166.                for(i=0;i<count;i++) { t2(4); buf[i] = r0(); }
  167.         t2(1); t2(0x20);
  168.         WR(4,0x10);
  169. break;
  171. case 2: WR(4,0x48);
  172. w0(0x40); w2(9); w2(0); w2(0x20);
  173. for (i=0;i<count;i++) buf[i] = r4();
  174. w2(0);
  175. WR(4,8);
  176. break;
  178.         case 3: WR(4,0x48);
  179.                 w0(0x40); w2(9); w2(0); w2(0x20);
  180.                 for (i=0;i<count/2;i++) ((u16 *)buf)[i] = r4w();
  181.                 w2(0);
  182.                 WR(4,8);
  183.                 break;
  185.         case 4: WR(4,0x48);
  186.                 w0(0x40); w2(9); w2(0); w2(0x20);
  187.                 for (i=0;i<count/4;i++) ((u32 *)buf)[i] = r4l();
  188.                 w2(0);
  189.                 WR(4,8);
  190.                 break;
  192. }
  193. }
  195. static int bpck_probe_unit ( PIA *pi )
  197. { int o1, o0, f7, id;
  198. int t, s;
  200. id = pi->unit;
  201. s = 0;
  202. w2(4); w2(0xe); r2(); t2(2); 
  203. o1 = r1()&0xf8;
  204. o0 = r0();
  205. w0(255-id); w2(4); w0(id);
  206. t2(8); t2(8); t2(8);
  207. t2(2); t = r1()&0xf8;
  208. f7 = ((id % 8) == 7);
  209. if ((f7) || (t != o1)) { t2(2); s = r1()&0xf8; }
  210. if ((t == o1) && ((!f7) || (s == o1)))  {
  211. w2(0x4c); w0(o0);
  212. return 0;
  213. }
  214. t2(8); w0(0); t2(2); w2(0x4c); w0(o0);
  215. return 1;
  216. }
  218. static void bpck_connect ( PIA *pi  )
  220. {       pi->saved_r0 = r0();
  221. w0(0xff-pi->unit); w2(4); w0(pi->unit);
  222. t2(8); t2(8); t2(8); 
  223. t2(2); t2(2);
  225. switch (pi->mode) {
  227. case 0: t2(8); WR(4,0);
  228. break;
  230. case 1: t2(8); WR(4,0x10);
  231. break;
  233. case 2:
  234.         case 3:
  235. case 4: w2(0); WR(4,8);
  236. break;
  238. }
  240. WR(5,8);
  242. if (pi->devtype == PI_PCD) {
  243. WR(0x46,0x10); /* fiddle with ESS logic ??? */
  244. WR(0x4c,0x38);
  245. WR(0x4d,0x88);
  246. WR(0x46,0xa0);
  247. WR(0x41,0);
  248. WR(0x4e,8);
  249. }
  250. }
  252. static void bpck_disconnect ( PIA *pi )
  254. { w0(0); 
  255. if (pi->mode >= 2) { w2(9); w2(0); } else t2(2);
  256. w2(0x4c); w0(pi->saved_r0);
  257. } 
  259. static void bpck_force_spp ( PIA *pi )
  261. /* This fakes the EPP protocol to turn off EPP ... */
  263. {       pi->saved_r0 = r0();
  264.         w0(0xff-pi->unit); w2(4); w0(pi->unit);
  265.         t2(8); t2(8); t2(8); 
  266.         t2(2); t2(2);
  268.         w2(0); 
  269.         w0(4); w2(9); w2(0); 
  270.         w0(0); w2(1); w2(3); w2(0);     
  271.         w0(0); w2(9); w2(0);
  272.         w2(0x4c); w0(pi->saved_r0);
  273. }
  275. #define TEST_LEN  16
  277. static int bpck_test_proto( PIA *pi, char * scratch, int verbose )
  279. { int i, e, l, h, om;
  280. char buf[TEST_LEN];
  282. bpck_force_spp(pi);
  284. switch (pi->mode) {
  286. case 0: bpck_connect(pi);
  287. WR(0x13,0x7f);
  288. w0(0x13); t2(2);
  289. for(i=0;i<TEST_LEN;i++) {
  290.                     t2(4); l = r1();
  291.                     t2(4); h = r1();
  292.                     buf[i] = j44(l,h);
  293. }
  294. bpck_disconnect(pi);
  295. break;
  297.         case 1: bpck_connect(pi);
  298. WR(0x13,0x7f);
  299.                 w0(0x13); t2(2); t2(0x20);
  300.                 for(i=0;i<TEST_LEN;i++) { t2(4); buf[i] = r0(); }
  301.                 t2(1); t2(0x20);
  302. bpck_disconnect(pi);
  303. break;
  305. case 2:
  306. case 3:
  307. case 4: om = pi->mode;
  308. pi->mode = 0;
  309. bpck_connect(pi);
  310. WR(7,3);
  311. WR(4,8);
  312. bpck_disconnect(pi);
  314. pi->mode = om;
  315. bpck_connect(pi);
  316. w0(0x13); w2(9); w2(1); w0(0); w2(3); w2(0); w2(0xe0);
  318. switch (pi->mode) {
  319.   case 2: for (i=0;i<TEST_LEN;i++) buf[i] = r4();
  320.   break;
  321.   case 3: for (i=0;i<TEST_LEN/2;i++) ((u16 *)buf)[i] = r4w();
  322.                           break;
  323.   case 4: for (i=0;i<TEST_LEN/4;i++) ((u32 *)buf)[i] = r4l();
  324.                           break;
  325. }
  327. w2(0);
  328. WR(7,0);
  329. bpck_disconnect(pi);
  331. break;
  333. }
  335. if (verbose) {
  336.     printk("%s: bpck: 0x%x unit %d mode %d: ",
  337.    pi->device,pi->port,pi->unit,pi->mode);
  338.     for (i=0;i<TEST_LEN;i++) printk("%3d",buf[i]);
  339.     printk("n");
  340. }
  342. e = 0;
  343. for (i=0;i<TEST_LEN;i++) if (buf[i] != (i+1)) e++;
  344. return e;
  345. }
  347. static void bpck_read_eeprom ( PIA *pi, char * buf )
  349. {       int i,j,k,n,p,v,f, om, od;
  351. bpck_force_spp(pi);
  353. om = pi->mode;  od = pi->delay;
  354. pi->mode = 0; pi->delay = 6;
  356. bpck_connect(pi);
  358. n = 0;
  359. WR(4,0);
  360. for (i=0;i<64;i++) {
  361.     WR(6,8);  
  362.     WR(6,0xc);
  363.     p = 0x100;
  364.     for (k=0;k<9;k++) {
  365. f = (((i + 0x180) & p) != 0) * 2;
  366. WR(6,f+0xc); 
  367. WR(6,f+0xd); 
  368. WR(6,f+0xc);
  369. p = (p >> 1);
  370.     }
  371.     for (j=0;j<2;j++) {
  372. v = 0;
  373. for (k=0;k<8;k++) {
  374.     WR(6,0xc); 
  375.     WR(6,0xd); 
  376.     WR(6,0xc); 
  377.     f = RR(0);
  378.     v = 2*v + (f == 0x84);
  379. }
  380. buf[2*i+1-j] = v;
  381.     }
  382. }
  383. WR(6,8);
  384. WR(6,0);
  385. WR(5,8);
  387. bpck_disconnect(pi);
  389.         if (om >= 2) {
  390.                 bpck_connect(pi);
  391.                 WR(7,3);
  392.                 WR(4,8);
  393.                 bpck_disconnect(pi);
  394.         }
  396. pi->mode = om; pi->delay = od;
  397. }
  399. static int bpck_test_port ( PIA *pi )  /* check for 8-bit port */
  401. { int i, r, m;
  403. w2(0x2c); i = r0(); w0(255-i); r = r0(); w0(i);
  404. m = -1;
  405. if (r == i) m = 2;
  406. if (r == (255-i)) m = 0;
  408. w2(0xc); i = r0(); w0(255-i); r = r0(); w0(i);
  409. if (r != (255-i)) m = -1;
  411. if (m == 0) { w2(6); w2(0xc); r = r0(); w0(0xaa); w0(r); w0(0xaa); }
  412. if (m == 2) { w2(0x26); w2(0xc); }
  414. if (m == -1) return 0;
  415. return 5;
  416. }
  418. static void bpck_log_adapter( PIA *pi, char * scratch, int verbose )
  420. { char *mode_string[5] = { "4-bit","8-bit","EPP-8",
  421.     "EPP-16","EPP-32" };
  423. #ifdef DUMP_EEPROM
  424. int i;
  425. #endif
  427. bpck_read_eeprom(pi,scratch);
  429. #ifdef DUMP_EEPROM
  430. if (verbose) {
  431.    for(i=0;i<128;i++)
  432. if ((scratch[i] < ' ') || (scratch[i] > '~'))
  433.     scratch[i] = '.';
  434.    printk("%s: bpck EEPROM: %64.64sn",pi->device,scratch);
  435.    printk("%s:              %64.64sn",pi->device,&scratch[64]);
  436. }
  437. #endif
  439. printk("%s: bpck %s, backpack %8.8s unit %d",
  440. pi->device,BPCK_VERSION,&scratch[110],pi->unit);
  441. printk(" at 0x%x, mode %d (%s), delay %dn",pi->port,
  442. pi->mode,mode_string[pi->mode],pi->delay);
  443. }
  445. static void bpck_init_proto( PIA *pi)
  447. { MOD_INC_USE_COUNT;
  448. }
  450. static void bpck_release_proto( PIA *pi)
  452. {       MOD_DEC_USE_COUNT;
  453. }
  455. struct pi_protocol bpck = { "bpck",0,5,2,4,256,
  456.   bpck_write_regr,
  457.   bpck_read_regr,
  458.   bpck_write_block,
  459.   bpck_read_block,
  460.   bpck_connect,
  461.   bpck_disconnect,
  462.   bpck_test_port,
  463.   bpck_probe_unit,
  464.           bpck_test_proto,
  465.   bpck_log_adapter,
  466.   bpck_init_proto,
  467.   bpck_release_proto
  468. };
  470. #ifdef MODULE
  472. int init_module(void)
  474. { return pi_register(&bpck) - 1;
  475. }
  477. void cleanup_module(void)
  479. { pi_unregister(&bpck);
  480. }
  482. #endif
  484. /* end of bpck.c */
  485. MODULE_LICENSE("GPL");