pms.c 20 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064
  1. /*
  2. * Media Vision Pro Movie Studio
  3. * or
  4. * "all you need is an I2C bus some RAM and a prayer"
  5. *
  6. * This draws heavily on code
  7. *
  8. * (c) Wolfgang Koehler, wolf@first.gmd.de, Dec. 1994
  9. * Kiefernring 15
  10. * 14478 Potsdam, Germany
  11. *
  12. * Most of this code is directly derived from his userspace driver.
  13. * His driver works so send any reports to alan@redhat.com unless the
  14. * userspace driver also doesn't work for you...
  15. *
  16. * Changes:
  17. * 08/07/2003 Daniele Bellucci <bellucda@tiscali.it>
  18. * - pms_capture: report back -EFAULT
  19. */
  20. #include <linux/module.h>
  21. #include <linux/delay.h>
  22. #include <linux/errno.h>
  23. #include <linux/fs.h>
  24. #include <linux/kernel.h>
  25. #include <linux/slab.h>
  26. #include <linux/mm.h>
  27. #include <linux/ioport.h>
  28. #include <linux/init.h>
  29. #include <asm/io.h>
  30. #include <linux/sched.h>
  31. #include <linux/videodev.h>
  32. #include <media/v4l2-common.h>
  33. #include <linux/mutex.h>
  34. #include <asm/uaccess.h>
  35. #define MOTOROLA 1
  36. #define PHILIPS2 2
  37. #define PHILIPS1 3
  38. #define MVVMEMORYWIDTH 0x40 /* 512 bytes */
  39. struct pms_device
  40. {
  41. struct video_device v;
  42. struct video_picture picture;
  43. int height;
  44. int width;
  45. struct mutex lock;
  46. };
  47. struct i2c_info
  48. {
  49. u8 slave;
  50. u8 sub;
  51. u8 data;
  52. u8 hits;
  53. };
  54. static int i2c_count = 0;
  55. static struct i2c_info i2cinfo[64];
  56. static int decoder = PHILIPS2;
  57. static int standard = 0; /* 0 - auto 1 - ntsc 2 - pal 3 - secam */
  58. /*
  59. * I/O ports and Shared Memory
  60. */
  61. static int io_port = 0x250;
  62. static int data_port = 0x251;
  63. static int mem_base = 0xC8000;
  64. static void __iomem *mem;
  65. static int video_nr = -1;
  66. static inline void mvv_write(u8 index, u8 value)
  67. {
  68. outw(index|(value<<8), io_port);
  69. }
  70. static inline u8 mvv_read(u8 index)
  71. {
  72. outb(index, io_port);
  73. return inb(data_port);
  74. }
  75. static int pms_i2c_stat(u8 slave)
  76. {
  77. int counter;
  78. int i;
  79. outb(0x28, io_port);
  80. counter=0;
  81. while((inb(data_port)&0x01)==0)
  82. if(counter++==256)
  83. break;
  84. while((inb(data_port)&0x01)!=0)
  85. if(counter++==256)
  86. break;
  87. outb(slave, io_port);
  88. counter=0;
  89. while((inb(data_port)&0x01)==0)
  90. if(counter++==256)
  91. break;
  92. while((inb(data_port)&0x01)!=0)
  93. if(counter++==256)
  94. break;
  95. for(i=0;i<12;i++)
  96. {
  97. char st=inb(data_port);
  98. if((st&2)!=0)
  99. return -1;
  100. if((st&1)==0)
  101. break;
  102. }
  103. outb(0x29, io_port);
  104. return inb(data_port);
  105. }
  106. static int pms_i2c_write(u16 slave, u16 sub, u16 data)
  107. {
  108. int skip=0;
  109. int count;
  110. int i;
  111. for(i=0;i<i2c_count;i++)
  112. {
  113. if((i2cinfo[i].slave==slave) &&
  114. (i2cinfo[i].sub == sub))
  115. {
  116. if(i2cinfo[i].data==data)
  117. skip=1;
  118. i2cinfo[i].data=data;
  119. i=i2c_count+1;
  120. }
  121. }
  122. if(i==i2c_count && i2c_count<64)
  123. {
  124. i2cinfo[i2c_count].slave=slave;
  125. i2cinfo[i2c_count].sub=sub;
  126. i2cinfo[i2c_count].data=data;
  127. i2c_count++;
  128. }
  129. if(skip)
  130. return 0;
  131. mvv_write(0x29, sub);
  132. mvv_write(0x2A, data);
  133. mvv_write(0x28, slave);
  134. outb(0x28, io_port);
  135. count=0;
  136. while((inb(data_port)&1)==0)
  137. if(count>255)
  138. break;
  139. while((inb(data_port)&1)!=0)
  140. if(count>255)
  141. break;
  142. count=inb(data_port);
  143. if(count&2)
  144. return -1;
  145. return count;
  146. }
  147. static int pms_i2c_read(int slave, int sub)
  148. {
  149. int i=0;
  150. for(i=0;i<i2c_count;i++)
  151. {
  152. if(i2cinfo[i].slave==slave && i2cinfo[i].sub==sub)
  153. return i2cinfo[i].data;
  154. }
  155. return 0;
  156. }
  157. static void pms_i2c_andor(int slave, int sub, int and, int or)
  158. {
  159. u8 tmp;
  160. tmp=pms_i2c_read(slave, sub);
  161. tmp = (tmp&and)|or;
  162. pms_i2c_write(slave, sub, tmp);
  163. }
  164. /*
  165. * Control functions
  166. */
  167. static void pms_videosource(short source)
  168. {
  169. mvv_write(0x2E, source?0x31:0x30);
  170. }
  171. static void pms_hue(short hue)
  172. {
  173. switch(decoder)
  174. {
  175. case MOTOROLA:
  176. pms_i2c_write(0x8A, 0x00, hue);
  177. break;
  178. case PHILIPS2:
  179. pms_i2c_write(0x8A, 0x07, hue);
  180. break;
  181. case PHILIPS1:
  182. pms_i2c_write(0x42, 0x07, hue);
  183. break;
  184. }
  185. }
  186. static void pms_colour(short colour)
  187. {
  188. switch(decoder)
  189. {
  190. case MOTOROLA:
  191. pms_i2c_write(0x8A, 0x00, colour);
  192. break;
  193. case PHILIPS1:
  194. pms_i2c_write(0x42, 0x12, colour);
  195. break;
  196. }
  197. }
  198. static void pms_contrast(short contrast)
  199. {
  200. switch(decoder)
  201. {
  202. case MOTOROLA:
  203. pms_i2c_write(0x8A, 0x00, contrast);
  204. break;
  205. case PHILIPS1:
  206. pms_i2c_write(0x42, 0x13, contrast);
  207. break;
  208. }
  209. }
  210. static void pms_brightness(short brightness)
  211. {
  212. switch(decoder)
  213. {
  214. case MOTOROLA:
  215. pms_i2c_write(0x8A, 0x00, brightness);
  216. pms_i2c_write(0x8A, 0x00, brightness);
  217. pms_i2c_write(0x8A, 0x00, brightness);
  218. break;
  219. case PHILIPS1:
  220. pms_i2c_write(0x42, 0x19, brightness);
  221. break;
  222. }
  223. }
  224. static void pms_format(short format)
  225. {
  226. int target;
  227. standard = format;
  228. if(decoder==PHILIPS1)
  229. target=0x42;
  230. else if(decoder==PHILIPS2)
  231. target=0x8A;
  232. else
  233. return;
  234. switch(format)
  235. {
  236. case 0: /* Auto */
  237. pms_i2c_andor(target, 0x0D, 0xFE,0x00);
  238. pms_i2c_andor(target, 0x0F, 0x3F,0x80);
  239. break;
  240. case 1: /* NTSC */
  241. pms_i2c_andor(target, 0x0D, 0xFE, 0x00);
  242. pms_i2c_andor(target, 0x0F, 0x3F, 0x40);
  243. break;
  244. case 2: /* PAL */
  245. pms_i2c_andor(target, 0x0D, 0xFE, 0x00);
  246. pms_i2c_andor(target, 0x0F, 0x3F, 0x00);
  247. break;
  248. case 3: /* SECAM */
  249. pms_i2c_andor(target, 0x0D, 0xFE, 0x01);
  250. pms_i2c_andor(target, 0x0F, 0x3F, 0x00);
  251. break;
  252. }
  253. }
  254. #ifdef FOR_FUTURE_EXPANSION
  255. /*
  256. * These features of the PMS card are not currently exposes. They
  257. * could become a private v4l ioctl for PMSCONFIG or somesuch if
  258. * people need it. We also don't yet use the PMS interrupt.
  259. */
  260. static void pms_hstart(short start)
  261. {
  262. switch(decoder)
  263. {
  264. case PHILIPS1:
  265. pms_i2c_write(0x8A, 0x05, start);
  266. pms_i2c_write(0x8A, 0x18, start);
  267. break;
  268. case PHILIPS2:
  269. pms_i2c_write(0x42, 0x05, start);
  270. pms_i2c_write(0x42, 0x18, start);
  271. break;
  272. }
  273. }
  274. /*
  275. * Bandpass filters
  276. */
  277. static void pms_bandpass(short pass)
  278. {
  279. if(decoder==PHILIPS2)
  280. pms_i2c_andor(0x8A, 0x06, 0xCF, (pass&0x03)<<4);
  281. else if(decoder==PHILIPS1)
  282. pms_i2c_andor(0x42, 0x06, 0xCF, (pass&0x03)<<4);
  283. }
  284. static void pms_antisnow(short snow)
  285. {
  286. if(decoder==PHILIPS2)
  287. pms_i2c_andor(0x8A, 0x06, 0xF3, (snow&0x03)<<2);
  288. else if(decoder==PHILIPS1)
  289. pms_i2c_andor(0x42, 0x06, 0xF3, (snow&0x03)<<2);
  290. }
  291. static void pms_sharpness(short sharp)
  292. {
  293. if(decoder==PHILIPS2)
  294. pms_i2c_andor(0x8A, 0x06, 0xFC, sharp&0x03);
  295. else if(decoder==PHILIPS1)
  296. pms_i2c_andor(0x42, 0x06, 0xFC, sharp&0x03);
  297. }
  298. static void pms_chromaagc(short agc)
  299. {
  300. if(decoder==PHILIPS2)
  301. pms_i2c_andor(0x8A, 0x0C, 0x9F, (agc&0x03)<<5);
  302. else if(decoder==PHILIPS1)
  303. pms_i2c_andor(0x42, 0x0C, 0x9F, (agc&0x03)<<5);
  304. }
  305. static void pms_vertnoise(short noise)
  306. {
  307. if(decoder==PHILIPS2)
  308. pms_i2c_andor(0x8A, 0x10, 0xFC, noise&3);
  309. else if(decoder==PHILIPS1)
  310. pms_i2c_andor(0x42, 0x10, 0xFC, noise&3);
  311. }
  312. static void pms_forcecolour(short colour)
  313. {
  314. if(decoder==PHILIPS2)
  315. pms_i2c_andor(0x8A, 0x0C, 0x7F, (colour&1)<<7);
  316. else if(decoder==PHILIPS1)
  317. pms_i2c_andor(0x42, 0x0C, 0x7, (colour&1)<<7);
  318. }
  319. static void pms_antigamma(short gamma)
  320. {
  321. if(decoder==PHILIPS2)
  322. pms_i2c_andor(0xB8, 0x00, 0x7F, (gamma&1)<<7);
  323. else if(decoder==PHILIPS1)
  324. pms_i2c_andor(0x42, 0x20, 0x7, (gamma&1)<<7);
  325. }
  326. static void pms_prefilter(short filter)
  327. {
  328. if(decoder==PHILIPS2)
  329. pms_i2c_andor(0x8A, 0x06, 0xBF, (filter&1)<<6);
  330. else if(decoder==PHILIPS1)
  331. pms_i2c_andor(0x42, 0x06, 0xBF, (filter&1)<<6);
  332. }
  333. static void pms_hfilter(short filter)
  334. {
  335. if(decoder==PHILIPS2)
  336. pms_i2c_andor(0xB8, 0x04, 0x1F, (filter&7)<<5);
  337. else if(decoder==PHILIPS1)
  338. pms_i2c_andor(0x42, 0x24, 0x1F, (filter&7)<<5);
  339. }
  340. static void pms_vfilter(short filter)
  341. {
  342. if(decoder==PHILIPS2)
  343. pms_i2c_andor(0xB8, 0x08, 0x9F, (filter&3)<<5);
  344. else if(decoder==PHILIPS1)
  345. pms_i2c_andor(0x42, 0x28, 0x9F, (filter&3)<<5);
  346. }
  347. static void pms_killcolour(short colour)
  348. {
  349. if(decoder==PHILIPS2)
  350. {
  351. pms_i2c_andor(0x8A, 0x08, 0x07, (colour&0x1F)<<3);
  352. pms_i2c_andor(0x8A, 0x09, 0x07, (colour&0x1F)<<3);
  353. }
  354. else if(decoder==PHILIPS1)
  355. {
  356. pms_i2c_andor(0x42, 0x08, 0x07, (colour&0x1F)<<3);
  357. pms_i2c_andor(0x42, 0x09, 0x07, (colour&0x1F)<<3);
  358. }
  359. }
  360. static void pms_chromagain(short chroma)
  361. {
  362. if(decoder==PHILIPS2)
  363. {
  364. pms_i2c_write(0x8A, 0x11, chroma);
  365. }
  366. else if(decoder==PHILIPS1)
  367. {
  368. pms_i2c_write(0x42, 0x11, chroma);
  369. }
  370. }
  371. static void pms_spacialcompl(short data)
  372. {
  373. mvv_write(0x3B, data);
  374. }
  375. static void pms_spacialcomph(short data)
  376. {
  377. mvv_write(0x3A, data);
  378. }
  379. static void pms_vstart(short start)
  380. {
  381. mvv_write(0x16, start);
  382. mvv_write(0x17, (start>>8)&0x01);
  383. }
  384. #endif
  385. static void pms_secamcross(short cross)
  386. {
  387. if(decoder==PHILIPS2)
  388. pms_i2c_andor(0x8A, 0x0F, 0xDF, (cross&1)<<5);
  389. else if(decoder==PHILIPS1)
  390. pms_i2c_andor(0x42, 0x0F, 0xDF, (cross&1)<<5);
  391. }
  392. static void pms_swsense(short sense)
  393. {
  394. if(decoder==PHILIPS2)
  395. {
  396. pms_i2c_write(0x8A, 0x0A, sense);
  397. pms_i2c_write(0x8A, 0x0B, sense);
  398. }
  399. else if(decoder==PHILIPS1)
  400. {
  401. pms_i2c_write(0x42, 0x0A, sense);
  402. pms_i2c_write(0x42, 0x0B, sense);
  403. }
  404. }
  405. static void pms_framerate(short frr)
  406. {
  407. int fps=(standard==1)?30:25;
  408. if(frr==0)
  409. return;
  410. fps=fps/frr;
  411. mvv_write(0x14,0x80|fps);
  412. mvv_write(0x15,1);
  413. }
  414. static void pms_vert(u8 deciden, u8 decinum)
  415. {
  416. mvv_write(0x1C, deciden); /* Denominator */
  417. mvv_write(0x1D, decinum); /* Numerator */
  418. }
  419. /*
  420. * Turn 16bit ratios into best small ratio the chipset can grok
  421. */
  422. static void pms_vertdeci(unsigned short decinum, unsigned short deciden)
  423. {
  424. /* Knock it down by /5 once */
  425. if(decinum%5==0)
  426. {
  427. deciden/=5;
  428. decinum/=5;
  429. }
  430. /*
  431. * 3's
  432. */
  433. while(decinum%3==0 && deciden%3==0)
  434. {
  435. deciden/=3;
  436. decinum/=3;
  437. }
  438. /*
  439. * 2's
  440. */
  441. while(decinum%2==0 && deciden%2==0)
  442. {
  443. decinum/=2;
  444. deciden/=2;
  445. }
  446. /*
  447. * Fudgyify
  448. */
  449. while(deciden>32)
  450. {
  451. deciden/=2;
  452. decinum=(decinum+1)/2;
  453. }
  454. if(deciden==32)
  455. deciden--;
  456. pms_vert(deciden,decinum);
  457. }
  458. static void pms_horzdeci(short decinum, short deciden)
  459. {
  460. if(decinum<=512)
  461. {
  462. if(decinum%5==0)
  463. {
  464. decinum/=5;
  465. deciden/=5;
  466. }
  467. }
  468. else
  469. {
  470. decinum=512;
  471. deciden=640; /* 768 would be ideal */
  472. }
  473. while(((decinum|deciden)&1)==0)
  474. {
  475. decinum>>=1;
  476. deciden>>=1;
  477. }
  478. while(deciden>32)
  479. {
  480. deciden>>=1;
  481. decinum=(decinum+1)>>1;
  482. }
  483. if(deciden==32)
  484. deciden--;
  485. mvv_write(0x24, 0x80|deciden);
  486. mvv_write(0x25, decinum);
  487. }
  488. static void pms_resolution(short width, short height)
  489. {
  490. int fg_height;
  491. fg_height=height;
  492. if(fg_height>280)
  493. fg_height=280;
  494. mvv_write(0x18, fg_height);
  495. mvv_write(0x19, fg_height>>8);
  496. if(standard==1)
  497. {
  498. mvv_write(0x1A, 0xFC);
  499. mvv_write(0x1B, 0x00);
  500. if(height>fg_height)
  501. pms_vertdeci(240,240);
  502. else
  503. pms_vertdeci(fg_height,240);
  504. }
  505. else
  506. {
  507. mvv_write(0x1A, 0x1A);
  508. mvv_write(0x1B, 0x01);
  509. if(fg_height>256)
  510. pms_vertdeci(270,270);
  511. else
  512. pms_vertdeci(fg_height, 270);
  513. }
  514. mvv_write(0x12,0);
  515. mvv_write(0x13, MVVMEMORYWIDTH);
  516. mvv_write(0x42, 0x00);
  517. mvv_write(0x43, 0x00);
  518. mvv_write(0x44, MVVMEMORYWIDTH);
  519. mvv_write(0x22, width+8);
  520. mvv_write(0x23, (width+8)>> 8);
  521. if(standard==1)
  522. pms_horzdeci(width,640);
  523. else
  524. pms_horzdeci(width+8, 768);
  525. mvv_write(0x30, mvv_read(0x30)&0xFE);
  526. mvv_write(0x08, mvv_read(0x08)|0x01);
  527. mvv_write(0x01, mvv_read(0x01)&0xFD);
  528. mvv_write(0x32, 0x00);
  529. mvv_write(0x33, MVVMEMORYWIDTH);
  530. }
  531. /*
  532. * Set Input
  533. */
  534. static void pms_vcrinput(short input)
  535. {
  536. if(decoder==PHILIPS2)
  537. pms_i2c_andor(0x8A,0x0D,0x7F,(input&1)<<7);
  538. else if(decoder==PHILIPS1)
  539. pms_i2c_andor(0x42,0x0D,0x7F,(input&1)<<7);
  540. }
  541. static int pms_capture(struct pms_device *dev, char __user *buf, int rgb555, int count)
  542. {
  543. int y;
  544. int dw = 2*dev->width;
  545. char tmp[dw+32]; /* using a temp buffer is faster than direct */
  546. int cnt = 0;
  547. int len=0;
  548. unsigned char r8 = 0x5; /* value for reg8 */
  549. if (rgb555)
  550. r8 |= 0x20; /* else use untranslated rgb = 565 */
  551. mvv_write(0x08,r8); /* capture rgb555/565, init DRAM, PC enable */
  552. /* printf("%d %d %d %d %d %x %x\n",width,height,voff,nom,den,mvv_buf); */
  553. for (y = 0; y < dev->height; y++ )
  554. {
  555. writeb(0, mem); /* synchronisiert neue Zeile */
  556. /*
  557. * This is in truth a fifo, be very careful as if you
  558. * forgot this odd things will occur 8)
  559. */
  560. memcpy_fromio(tmp, mem, dw+32); /* discard 16 word */
  561. cnt -= dev->height;
  562. while (cnt <= 0)
  563. {
  564. /*
  565. * Don't copy too far
  566. */
  567. int dt=dw;
  568. if(dt+len>count)
  569. dt=count-len;
  570. cnt += dev->height;
  571. if (copy_to_user(buf, tmp+32, dt))
  572. return len ? len : -EFAULT;
  573. buf += dt;
  574. len += dt;
  575. }
  576. }
  577. return len;
  578. }
  579. /*
  580. * Video4linux interfacing
  581. */
  582. static int pms_do_ioctl(struct inode *inode, struct file *file,
  583. unsigned int cmd, void *arg)
  584. {
  585. struct video_device *dev = video_devdata(file);
  586. struct pms_device *pd=(struct pms_device *)dev;
  587. switch(cmd)
  588. {
  589. case VIDIOCGCAP:
  590. {
  591. struct video_capability *b = arg;
  592. strcpy(b->name, "Mediavision PMS");
  593. b->type = VID_TYPE_CAPTURE|VID_TYPE_SCALES;
  594. b->channels = 4;
  595. b->audios = 0;
  596. b->maxwidth = 640;
  597. b->maxheight = 480;
  598. b->minwidth = 16;
  599. b->minheight = 16;
  600. return 0;
  601. }
  602. case VIDIOCGCHAN:
  603. {
  604. struct video_channel *v = arg;
  605. if(v->channel<0 || v->channel>3)
  606. return -EINVAL;
  607. v->flags=0;
  608. v->tuners=1;
  609. /* Good question.. its composite or SVHS so.. */
  610. v->type = VIDEO_TYPE_CAMERA;
  611. switch(v->channel)
  612. {
  613. case 0:
  614. strcpy(v->name, "Composite");break;
  615. case 1:
  616. strcpy(v->name, "SVideo");break;
  617. case 2:
  618. strcpy(v->name, "Composite(VCR)");break;
  619. case 3:
  620. strcpy(v->name, "SVideo(VCR)");break;
  621. }
  622. return 0;
  623. }
  624. case VIDIOCSCHAN:
  625. {
  626. struct video_channel *v = arg;
  627. if(v->channel<0 || v->channel>3)
  628. return -EINVAL;
  629. mutex_lock(&pd->lock);
  630. pms_videosource(v->channel&1);
  631. pms_vcrinput(v->channel>>1);
  632. mutex_unlock(&pd->lock);
  633. return 0;
  634. }
  635. case VIDIOCGTUNER:
  636. {
  637. struct video_tuner *v = arg;
  638. if(v->tuner)
  639. return -EINVAL;
  640. strcpy(v->name, "Format");
  641. v->rangelow=0;
  642. v->rangehigh=0;
  643. v->flags= VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
  644. switch(standard)
  645. {
  646. case 0:
  647. v->mode = VIDEO_MODE_AUTO;
  648. break;
  649. case 1:
  650. v->mode = VIDEO_MODE_NTSC;
  651. break;
  652. case 2:
  653. v->mode = VIDEO_MODE_PAL;
  654. break;
  655. case 3:
  656. v->mode = VIDEO_MODE_SECAM;
  657. break;
  658. }
  659. return 0;
  660. }
  661. case VIDIOCSTUNER:
  662. {
  663. struct video_tuner *v = arg;
  664. if(v->tuner)
  665. return -EINVAL;
  666. mutex_lock(&pd->lock);
  667. switch(v->mode)
  668. {
  669. case VIDEO_MODE_AUTO:
  670. pms_framerate(25);
  671. pms_secamcross(0);
  672. pms_format(0);
  673. break;
  674. case VIDEO_MODE_NTSC:
  675. pms_framerate(30);
  676. pms_secamcross(0);
  677. pms_format(1);
  678. break;
  679. case VIDEO_MODE_PAL:
  680. pms_framerate(25);
  681. pms_secamcross(0);
  682. pms_format(2);
  683. break;
  684. case VIDEO_MODE_SECAM:
  685. pms_framerate(25);
  686. pms_secamcross(1);
  687. pms_format(2);
  688. break;
  689. default:
  690. mutex_unlock(&pd->lock);
  691. return -EINVAL;
  692. }
  693. mutex_unlock(&pd->lock);
  694. return 0;
  695. }
  696. case VIDIOCGPICT:
  697. {
  698. struct video_picture *p = arg;
  699. *p = pd->picture;
  700. return 0;
  701. }
  702. case VIDIOCSPICT:
  703. {
  704. struct video_picture *p = arg;
  705. if(!((p->palette==VIDEO_PALETTE_RGB565 && p->depth==16)
  706. ||(p->palette==VIDEO_PALETTE_RGB555 && p->depth==15)))
  707. return -EINVAL;
  708. pd->picture= *p;
  709. /*
  710. * Now load the card.
  711. */
  712. mutex_lock(&pd->lock);
  713. pms_brightness(p->brightness>>8);
  714. pms_hue(p->hue>>8);
  715. pms_colour(p->colour>>8);
  716. pms_contrast(p->contrast>>8);
  717. mutex_unlock(&pd->lock);
  718. return 0;
  719. }
  720. case VIDIOCSWIN:
  721. {
  722. struct video_window *vw = arg;
  723. if(vw->flags)
  724. return -EINVAL;
  725. if(vw->clipcount)
  726. return -EINVAL;
  727. if(vw->height<16||vw->height>480)
  728. return -EINVAL;
  729. if(vw->width<16||vw->width>640)
  730. return -EINVAL;
  731. pd->width=vw->width;
  732. pd->height=vw->height;
  733. mutex_lock(&pd->lock);
  734. pms_resolution(pd->width, pd->height);
  735. mutex_unlock(&pd->lock); /* Ok we figured out what to use from our wide choice */
  736. return 0;
  737. }
  738. case VIDIOCGWIN:
  739. {
  740. struct video_window *vw = arg;
  741. memset(vw,0,sizeof(*vw));
  742. vw->width=pd->width;
  743. vw->height=pd->height;
  744. return 0;
  745. }
  746. case VIDIOCKEY:
  747. return 0;
  748. case VIDIOCCAPTURE:
  749. case VIDIOCGFBUF:
  750. case VIDIOCSFBUF:
  751. case VIDIOCGFREQ:
  752. case VIDIOCSFREQ:
  753. case VIDIOCGAUDIO:
  754. case VIDIOCSAUDIO:
  755. return -EINVAL;
  756. default:
  757. return -ENOIOCTLCMD;
  758. }
  759. return 0;
  760. }
  761. static int pms_ioctl(struct inode *inode, struct file *file,
  762. unsigned int cmd, unsigned long arg)
  763. {
  764. return video_usercopy(inode, file, cmd, arg, pms_do_ioctl);
  765. }
  766. static ssize_t pms_read(struct file *file, char __user *buf,
  767. size_t count, loff_t *ppos)
  768. {
  769. struct video_device *v = video_devdata(file);
  770. struct pms_device *pd=(struct pms_device *)v;
  771. int len;
  772. mutex_lock(&pd->lock);
  773. len=pms_capture(pd, buf, (pd->picture.depth==16)?0:1,count);
  774. mutex_unlock(&pd->lock);
  775. return len;
  776. }
  777. static struct file_operations pms_fops = {
  778. .owner = THIS_MODULE,
  779. .open = video_exclusive_open,
  780. .release = video_exclusive_release,
  781. .ioctl = pms_ioctl,
  782. .compat_ioctl = v4l_compat_ioctl32,
  783. .read = pms_read,
  784. .llseek = no_llseek,
  785. };
  786. static struct video_device pms_template=
  787. {
  788. .owner = THIS_MODULE,
  789. .name = "Mediavision PMS",
  790. .type = VID_TYPE_CAPTURE,
  791. .hardware = VID_HARDWARE_PMS,
  792. .fops = &pms_fops,
  793. };
  794. static struct pms_device pms_device;
  795. /*
  796. * Probe for and initialise the Mediavision PMS
  797. */
  798. static int init_mediavision(void)
  799. {
  800. int id;
  801. int idec, decst;
  802. int i;
  803. unsigned char i2c_defs[]={
  804. 0x4C,0x30,0x00,0xE8,
  805. 0xB6,0xE2,0x00,0x00,
  806. 0xFF,0xFF,0x00,0x00,
  807. 0x00,0x00,0x78,0x98,
  808. 0x00,0x00,0x00,0x00,
  809. 0x34,0x0A,0xF4,0xCE,
  810. 0xE4
  811. };
  812. mem = ioremap(mem_base, 0x800);
  813. if (!mem)
  814. return -ENOMEM;
  815. if (!request_region(0x9A01, 1, "Mediavision PMS config"))
  816. {
  817. printk(KERN_WARNING "mediavision: unable to detect: 0x9A01 in use.\n");
  818. iounmap(mem);
  819. return -EBUSY;
  820. }
  821. if (!request_region(io_port, 3, "Mediavision PMS"))
  822. {
  823. printk(KERN_WARNING "mediavision: I/O port %d in use.\n", io_port);
  824. release_region(0x9A01, 1);
  825. iounmap(mem);
  826. return -EBUSY;
  827. }
  828. outb(0xB8, 0x9A01); /* Unlock */
  829. outb(io_port>>4, 0x9A01); /* Set IO port */
  830. id=mvv_read(3);
  831. decst=pms_i2c_stat(0x43);
  832. if(decst!=-1)
  833. idec=2;
  834. else if(pms_i2c_stat(0xb9)!=-1)
  835. idec=3;
  836. else if(pms_i2c_stat(0x8b)!=-1)
  837. idec=1;
  838. else
  839. idec=0;
  840. printk(KERN_INFO "PMS type is %d\n", idec);
  841. if(idec == 0) {
  842. release_region(io_port, 3);
  843. release_region(0x9A01, 1);
  844. iounmap(mem);
  845. return -ENODEV;
  846. }
  847. /*
  848. * Ok we have a PMS of some sort
  849. */
  850. mvv_write(0x04, mem_base>>12); /* Set the memory area */
  851. /* Ok now load the defaults */
  852. for(i=0;i<0x19;i++)
  853. {
  854. if(i2c_defs[i]==0xFF)
  855. pms_i2c_andor(0x8A, i, 0x07,0x00);
  856. else
  857. pms_i2c_write(0x8A, i, i2c_defs[i]);
  858. }
  859. pms_i2c_write(0xB8,0x00,0x12);
  860. pms_i2c_write(0xB8,0x04,0x00);
  861. pms_i2c_write(0xB8,0x07,0x00);
  862. pms_i2c_write(0xB8,0x08,0x00);
  863. pms_i2c_write(0xB8,0x09,0xFF);
  864. pms_i2c_write(0xB8,0x0A,0x00);
  865. pms_i2c_write(0xB8,0x0B,0x10);
  866. pms_i2c_write(0xB8,0x10,0x03);
  867. mvv_write(0x01, 0x00);
  868. mvv_write(0x05, 0xA0);
  869. mvv_write(0x08, 0x25);
  870. mvv_write(0x09, 0x00);
  871. mvv_write(0x0A, 0x20|MVVMEMORYWIDTH);
  872. mvv_write(0x10, 0x02);
  873. mvv_write(0x1E, 0x0C);
  874. mvv_write(0x1F, 0x03);
  875. mvv_write(0x26, 0x06);
  876. mvv_write(0x2B, 0x00);
  877. mvv_write(0x2C, 0x20);
  878. mvv_write(0x2D, 0x00);
  879. mvv_write(0x2F, 0x70);
  880. mvv_write(0x32, 0x00);
  881. mvv_write(0x33, MVVMEMORYWIDTH);
  882. mvv_write(0x34, 0x00);
  883. mvv_write(0x35, 0x00);
  884. mvv_write(0x3A, 0x80);
  885. mvv_write(0x3B, 0x10);
  886. mvv_write(0x20, 0x00);
  887. mvv_write(0x21, 0x00);
  888. mvv_write(0x30, 0x22);
  889. return 0;
  890. }
  891. /*
  892. * Initialization and module stuff
  893. */
  894. static int __init init_pms_cards(void)
  895. {
  896. printk(KERN_INFO "Mediavision Pro Movie Studio driver 0.02\n");
  897. data_port = io_port +1;
  898. if(init_mediavision())
  899. {
  900. printk(KERN_INFO "Board not found.\n");
  901. return -ENODEV;
  902. }
  903. memcpy(&pms_device, &pms_template, sizeof(pms_template));
  904. mutex_init(&pms_device.lock);
  905. pms_device.height=240;
  906. pms_device.width=320;
  907. pms_swsense(75);
  908. pms_resolution(320,240);
  909. return video_register_device((struct video_device *)&pms_device, VFL_TYPE_GRABBER, video_nr);
  910. }
  911. module_param(io_port, int, 0);
  912. module_param(mem_base, int, 0);
  913. module_param(video_nr, int, 0);
  914. MODULE_LICENSE("GPL");
  915. static void __exit shutdown_mediavision(void)
  916. {
  917. release_region(io_port,3);
  918. release_region(0x9A01, 1);
  919. }
  920. static void __exit cleanup_pms_module(void)
  921. {
  922. shutdown_mediavision();
  923. video_unregister_device((struct video_device *)&pms_device);
  924. iounmap(mem);
  925. }
  926. module_init(init_pms_cards);
  927. module_exit(cleanup_pms_module);