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

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

Linux/Unix编程

开发平台：

Unix_Linux

sonypi.c：源码内容
  1. /* 
  2.  * Sony Programmable I/O Control Device driver for VAIO
  3.  *
  4.  * Copyright (C) 2001 Stelian Pop <stelian.pop@fr.alcove.com>, Alc魐e
  5.  *
  6.  * Copyright (C) 2001 Michael Ashley <m.ashley@unsw.edu.au>
  7.  *
  8.  * Copyright (C) 2001 Junichi Morita <jun1m@mars.dti.ne.jp>
  9.  *
  10.  * Copyright (C) 2000 Takaya Kinjo <t-kinjo@tc4.so-net.ne.jp>
  11.  *
  12.  * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
  13.  *
  14.  * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
  15.  *
  16.  * This program is free software; you can redistribute it and/or modify
  17.  * it under the terms of the GNU General Public License as published by
  18.  * the Free Software Foundation; either version 2 of the License, or
  19.  * (at your option) any later version.
  20.  * 
  21.  * This program is distributed in the hope that it will be useful,
  22.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24.  * GNU General Public License for more details.
  25.  * 
  26.  * You should have received a copy of the GNU General Public License
  27.  * along with this program; if not, write to the Free Software
  28.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29.  *
  30.  */
  32. #include <linux/config.h>
  33. #include <linux/module.h>
  34. #include <linux/pci.h>
  35. #include <linux/sched.h>
  36. #include <linux/init.h>
  37. #include <linux/miscdevice.h>
  38. #include <linux/poll.h>
  39. #include <linux/delay.h>
  40. #include <asm/uaccess.h>
  41. #include <asm/io.h>
  42. #include <asm/system.h>
  44. #include "sonypi.h"
  45. #include <linux/sonypi.h>
  47. static struct sonypi_device sonypi_device;
  48. static int minor = -1;
  49. static int verbose; /* = 0 */
  50. static int fnkeyinit; /* = 0 */
  51. static int camera; /* = 0 */
  52. static int compat; /* = 0 */
  53. static int nojogdial; /* = 0 */
  55. /* Inits the queue */
  56. static inline void sonypi_initq(void) {
  57.         sonypi_device.queue.head = sonypi_device.queue.tail = 0;
  58. sonypi_device.queue.len = 0;
  59. sonypi_device.queue.s_lock = (spinlock_t)SPIN_LOCK_UNLOCKED;
  60. init_waitqueue_head(&sonypi_device.queue.proc_list);
  61. }
  63. /* Pulls an event from the queue */
  64. static inline unsigned char sonypi_pullq(void) {
  65.         unsigned char result;
  66. unsigned long flags;
  68. spin_lock_irqsave(&sonypi_device.queue.s_lock, flags);
  69. if (!sonypi_device.queue.len) {
  70. spin_unlock_irqrestore(&sonypi_device.queue.s_lock, flags);
  71. return 0;
  72. }
  73. result = sonypi_device.queue.buf[sonypi_device.queue.head];
  74.         sonypi_device.queue.head++;
  75. sonypi_device.queue.head &= (SONYPI_BUF_SIZE - 1);
  76. sonypi_device.queue.len--;
  77. spin_unlock_irqrestore(&sonypi_device.queue.s_lock, flags);
  78.         return result;
  79. }
  81. /* Pushes an event into the queue */
  82. static inline void sonypi_pushq(unsigned char event) {
  83. unsigned long flags;
  85. spin_lock_irqsave(&sonypi_device.queue.s_lock, flags);
  86. if (sonypi_device.queue.len == SONYPI_BUF_SIZE) {
  87. /* remove the first element */
  88.          sonypi_device.queue.head++;
  89. sonypi_device.queue.head &= (SONYPI_BUF_SIZE - 1);
  90. sonypi_device.queue.len--;
  91. }
  92. sonypi_device.queue.buf[sonypi_device.queue.tail] = event;
  93. sonypi_device.queue.tail++;
  94. sonypi_device.queue.tail &= (SONYPI_BUF_SIZE - 1);
  95. sonypi_device.queue.len++;
  97. kill_fasync(&sonypi_device.queue.fasync, SIGIO, POLL_IN);
  98. wake_up_interruptible(&sonypi_device.queue.proc_list);
  99. spin_unlock_irqrestore(&sonypi_device.queue.s_lock, flags);
  100. }
  102. /* Tests if the queue is empty */
  103. static inline int sonypi_emptyq(void) {
  104.         int result;
  105. unsigned long flags;
  107. spin_lock_irqsave(&sonypi_device.queue.s_lock, flags);
  108.         result = (sonypi_device.queue.len == 0);
  109. spin_unlock_irqrestore(&sonypi_device.queue.s_lock, flags);
  110.         return result;
  111. }
  113. static void sonypi_ecrset(u8 addr, u8 value) {
  115. wait_on_command(1, inb_p(SONYPI_CST_IOPORT) & 3);
  116. outb_p(0x81, SONYPI_CST_IOPORT);
  117. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  118. outb_p(addr, SONYPI_DATA_IOPORT);
  119. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  120. outb_p(value, SONYPI_DATA_IOPORT);
  121. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  122. }
  124. static u8 sonypi_ecrget(u8 addr) {
  126. wait_on_command(1, inb_p(SONYPI_CST_IOPORT) & 3);
  127. outb_p(0x80, SONYPI_CST_IOPORT);
  128. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  129. outb_p(addr, SONYPI_DATA_IOPORT);
  130. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  131. return inb_p(SONYPI_DATA_IOPORT);
  132. }
  134. static u16 sonypi_ecrget16(u8 addr) {
  135. return sonypi_ecrget(addr) | (sonypi_ecrget(addr + 1) << 8);
  136. }
  138. /* Initializes the device - this comes from the AML code in the ACPI bios */
  139. static void __devinit sonypi_type1_srs(void) {
  140. u32 v;
  142. pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
  143. v = (v & 0xFFFF0000) | ((u32)sonypi_device.ioport1);
  144. pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
  146. pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
  147. v = (v & 0xFFF0FFFF) | 
  148.     (((u32)sonypi_device.ioport1 ^ sonypi_device.ioport2) << 16);
  149. pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
  151. v = inl(SONYPI_IRQ_PORT);
  152. v &= ~(((u32)0x3) << SONYPI_IRQ_SHIFT);
  153. v |= (((u32)sonypi_device.bits) << SONYPI_IRQ_SHIFT);
  154. outl(v, SONYPI_IRQ_PORT);
  156. pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
  157. v = (v & 0xFF1FFFFF) | 0x00C00000;
  158. pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
  159. }
  161. static void __devinit sonypi_type2_srs(void) {
  162. sonypi_ecrset(SONYPI_SHIB, (sonypi_device.ioport1 & 0xFF00) >> 8);
  163. sonypi_ecrset(SONYPI_SLOB,  sonypi_device.ioport1 & 0x00FF);
  164. sonypi_ecrset(SONYPI_SIRQ,  sonypi_device.bits);
  165. udelay(10);
  166. }
  168. /* Disables the device - this comes from the AML code in the ACPI bios */
  169. static void __devexit sonypi_type1_dis(void) {
  170. u32 v;
  172. pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
  173. v = v & 0xFF3FFFFF;
  174. pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
  176. v = inl(SONYPI_IRQ_PORT);
  177. v |= (0x3 << SONYPI_IRQ_SHIFT);
  178. outl(v, SONYPI_IRQ_PORT);
  179. }
  181. static void __devexit sonypi_type2_dis(void) {
  182. sonypi_ecrset(SONYPI_SHIB, 0);
  183. sonypi_ecrset(SONYPI_SLOB, 0);
  184. sonypi_ecrset(SONYPI_SIRQ, 0);
  185. }
  187. static u8 sonypi_call1(u8 dev) {
  188. u8 v1, v2;
  190. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  191. outb(dev, sonypi_device.ioport2);
  192. v1 = inb_p(sonypi_device.ioport2);
  193. v2 = inb_p(sonypi_device.ioport1);
  194. return v2;
  195. }
  197. static u8 sonypi_call2(u8 dev, u8 fn) {
  198. u8 v1;
  200. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  201. outb(dev, sonypi_device.ioport2);
  202. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  203. outb(fn, sonypi_device.ioport1);
  204. v1 = inb_p(sonypi_device.ioport1);
  205. return v1;
  206. }
  208. static u8 sonypi_call3(u8 dev, u8 fn, u8 v) {
  209. u8 v1;
  211. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  212. outb(dev, sonypi_device.ioport2);
  213. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  214. outb(fn, sonypi_device.ioport1);
  215. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  216. outb(v, sonypi_device.ioport1);
  217. v1 = inb_p(sonypi_device.ioport1);
  218. return v1;
  219. }
  221. static u8 sonypi_read(u8 fn) {
  222. u8 v1, v2;
  223. int n = 100;
  225. while (n--) {
  226. v1 = sonypi_call2(0x8f, fn);
  227. v2 = sonypi_call2(0x8f, fn);
  228. if (v1 == v2 && v1 != 0xff)
  229. return v1;
  230. }
  231. return 0xff;
  232. }
  234. /* Set brightness, hue etc */
  235. static void sonypi_set(u8 fn, u8 v) {
  237. wait_on_command(0, sonypi_call3(0x90, fn, v));
  238. }
  240. /* Tests if the camera is ready */
  241. static int sonypi_camera_ready(void) {
  242. u8 v;
  244. v = sonypi_call2(0x8f, SONYPI_CAMERA_STATUS);
  245. return (v != 0xff && (v & SONYPI_CAMERA_STATUS_READY));
  246. }
  248. /* Turns the camera off */
  249. static void sonypi_camera_off(void) {
  251. sonypi_set(SONYPI_CAMERA_PICTURE, SONYPI_CAMERA_MUTE_MASK);
  253. if (!sonypi_device.camera_power)
  254. return;
  256. sonypi_call2(0x91, 0); 
  257. sonypi_device.camera_power = 0;
  258. }
  260. /* Turns the camera on */
  261. static void sonypi_camera_on(void) {
  262. int i, j;
  264. if (sonypi_device.camera_power)
  265. return;
  267. for (j = 5; j > 0; j--) {
  269. while (sonypi_call2(0x91, 0x1) != 0) {
  270. set_current_state(TASK_UNINTERRUPTIBLE);
  271. schedule_timeout(1);
  272. }
  273. sonypi_call1(0x93);
  275. for (i = 400; i > 0; i--) {
  276. if (sonypi_camera_ready())
  277. break;
  278. set_current_state(TASK_UNINTERRUPTIBLE);
  279. schedule_timeout(1);
  280. }
  281. if (i != 0)
  282. break;
  283. }
  285. if (j == 0) {
  286. printk(KERN_WARNING "sonypi: failed to power on cameran");
  287. return;
  288. }
  290. sonypi_set(0x10, 0x5a);
  291. sonypi_device.camera_power = 1;
  292. }
  294. /* sets the bluetooth subsystem power state */
  295. static void sonypi_setbluetoothpower(u8 state) {
  297. state = (state != 0);
  298. if (sonypi_device.bluetooth_power && state) 
  299. return;
  300. if (!sonypi_device.bluetooth_power && !state) 
  301. return;
  303. sonypi_call2(0x96, state);
  304. sonypi_call1(0x93);
  305. sonypi_device.bluetooth_power = state;
  306. }
  308. /* Interrupt handler: some event is available */
  309. void sonypi_irq(int irq, void *dev_id, struct pt_regs *regs) {
  310. u8 v1, v2, event = 0;
  311. int i;
  312. u8 sonypi_jogger_ev, sonypi_fnkey_ev;
  313. u8 sonypi_capture_ev, sonypi_bluetooth_ev;
  314. u8 sonypi_pkey_ev;
  316. if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2) {
  317. sonypi_jogger_ev = SONYPI_TYPE2_JOGGER_EV;
  318. sonypi_fnkey_ev = SONYPI_TYPE2_FNKEY_EV;
  319. sonypi_capture_ev = SONYPI_TYPE2_CAPTURE_EV;
  320. sonypi_bluetooth_ev = SONYPI_TYPE2_BLUETOOTH_EV;
  321. sonypi_pkey_ev = nojogdial ? SONYPI_TYPE2_PKEY_EV 
  322.    : SONYPI_TYPE1_PKEY_EV;
  323. }
  324. else {
  325. sonypi_jogger_ev = SONYPI_TYPE1_JOGGER_EV;
  326. sonypi_fnkey_ev = SONYPI_TYPE1_FNKEY_EV;
  327. sonypi_capture_ev = SONYPI_TYPE1_CAPTURE_EV;
  328. sonypi_bluetooth_ev = SONYPI_TYPE1_BLUETOOTH_EV;
  329. sonypi_pkey_ev = SONYPI_TYPE1_PKEY_EV;
  330. }
  332. v1 = inb_p(sonypi_device.ioport1);
  333. v2 = inb_p(sonypi_device.ioport2);
  335. if ((v2 & sonypi_pkey_ev) == sonypi_pkey_ev) {
  336. for (i = 0; sonypi_pkeyev[i].event; i++)
  337. if (sonypi_pkeyev[i].data == v1) {
  338. event = sonypi_pkeyev[i].event;
  339. goto found;
  340. }
  341. }
  342. if ((v2 & sonypi_jogger_ev) == sonypi_jogger_ev) {
  343. for (i = 0; sonypi_joggerev[i].event; i++)
  344. if (sonypi_joggerev[i].data == v1) {
  345. event = sonypi_joggerev[i].event;
  346. goto found;
  347. }
  348. }
  349. if ((v2 & sonypi_capture_ev) == sonypi_capture_ev) {
  350. for (i = 0; sonypi_captureev[i].event; i++)
  351. if (sonypi_captureev[i].data == v1) {
  352. event = sonypi_captureev[i].event;
  353. goto found;
  354. }
  355. }
  356. if ((v2 & sonypi_fnkey_ev) == sonypi_fnkey_ev) {
  357. for (i = 0; sonypi_fnkeyev[i].event; i++)
  358. if (sonypi_fnkeyev[i].data == v1) {
  359. event = sonypi_fnkeyev[i].event;
  360. goto found;
  361. }
  362. }
  363. if ((v2 & sonypi_bluetooth_ev) == sonypi_bluetooth_ev) {
  364. for (i = 0; sonypi_blueev[i].event; i++)
  365. if (sonypi_blueev[i].data == v1) {
  366. event = sonypi_blueev[i].event;
  367. goto found;
  368. }
  369. }
  370. if ((v2 & SONYPI_BACK_EV) == SONYPI_BACK_EV) {
  371. for (i = 0; sonypi_backev[i].event; i++)
  372. if (sonypi_backev[i].data == v1) {
  373. event = sonypi_backev[i].event;
  374. goto found;
  375. }
  376. }
  377. if ((v2 & SONYPI_LID_EV) == SONYPI_LID_EV) {
  378. for (i = 0; sonypi_lidev[i].event; i++)
  379. if (sonypi_lidev[i].data == v1) {
  380. event = sonypi_lidev[i].event;
  381. goto found;
  382. }
  383. }
  384. if (verbose)
  385. printk(KERN_WARNING 
  386.        "sonypi: unknown event port1=0x%02x,port2=0x%02xn",v1,v2);
  387. return;
  389. found:
  390. sonypi_pushq(event);
  391. }
  393. /* External camera command (exported to the motion eye v4l driver) */
  394. u8 sonypi_camera_command(int command, u8 value) {
  395. u8 ret = 0;
  397. if (!camera)
  398. return 0;
  400. down(&sonypi_device.lock);
  402. switch(command) {
  403. case SONYPI_COMMAND_GETCAMERA:
  404. ret = sonypi_camera_ready();
  405. break;
  406. case SONYPI_COMMAND_SETCAMERA:
  407. if (value)
  408. sonypi_camera_on();
  409. else
  410. sonypi_camera_off();
  411. break;
  412. case SONYPI_COMMAND_GETCAMERABRIGHTNESS:
  413. ret = sonypi_read(SONYPI_CAMERA_BRIGHTNESS);
  414. break;
  415. case SONYPI_COMMAND_SETCAMERABRIGHTNESS:
  416. sonypi_set(SONYPI_CAMERA_BRIGHTNESS, value);
  417. break;
  418. case SONYPI_COMMAND_GETCAMERACONTRAST:
  419. ret = sonypi_read(SONYPI_CAMERA_CONTRAST);
  420. break;
  421. case SONYPI_COMMAND_SETCAMERACONTRAST:
  422. sonypi_set(SONYPI_CAMERA_CONTRAST, value);
  423. break;
  424. case SONYPI_COMMAND_GETCAMERAHUE:
  425. ret = sonypi_read(SONYPI_CAMERA_HUE);
  426. break;
  427. case SONYPI_COMMAND_SETCAMERAHUE:
  428. sonypi_set(SONYPI_CAMERA_HUE, value);
  429. break;
  430. case SONYPI_COMMAND_GETCAMERACOLOR:
  431. ret = sonypi_read(SONYPI_CAMERA_COLOR);
  432. break;
  433. case SONYPI_COMMAND_SETCAMERACOLOR:
  434. sonypi_set(SONYPI_CAMERA_COLOR, value);
  435. break;
  436. case SONYPI_COMMAND_GETCAMERASHARPNESS:
  437. ret = sonypi_read(SONYPI_CAMERA_SHARPNESS);
  438. break;
  439. case SONYPI_COMMAND_SETCAMERASHARPNESS:
  440. sonypi_set(SONYPI_CAMERA_SHARPNESS, value);
  441. break;
  442. case SONYPI_COMMAND_GETCAMERAPICTURE:
  443. ret = sonypi_read(SONYPI_CAMERA_PICTURE);
  444. break;
  445. case SONYPI_COMMAND_SETCAMERAPICTURE:
  446. sonypi_set(SONYPI_CAMERA_PICTURE, value);
  447. break;
  448. case SONYPI_COMMAND_GETCAMERAAGC:
  449. ret = sonypi_read(SONYPI_CAMERA_AGC);
  450. break;
  451. case SONYPI_COMMAND_SETCAMERAAGC:
  452. sonypi_set(SONYPI_CAMERA_AGC, value);
  453. break;
  454. case SONYPI_COMMAND_GETCAMERADIRECTION:
  455. ret = sonypi_read(SONYPI_CAMERA_STATUS);
  456. ret &= SONYPI_DIRECTION_BACKWARDS;
  457. break;
  458. case SONYPI_COMMAND_GETCAMERAROMVERSION:
  459. ret = sonypi_read(SONYPI_CAMERA_ROMVERSION);
  460. break;
  461. case SONYPI_COMMAND_GETCAMERAREVISION:
  462. ret = sonypi_read(SONYPI_CAMERA_REVISION);
  463. break;
  464. }
  465. up(&sonypi_device.lock);
  466. return ret;
  467. }
  469. static int sonypi_misc_fasync(int fd, struct file *filp, int on) {
  470. int retval;
  472. retval = fasync_helper(fd, filp, on, &sonypi_device.queue.fasync);
  473. if (retval < 0)
  474. return retval;
  475. return 0;
  476. }
  478. static int sonypi_misc_release(struct inode * inode, struct file * file) {
  479. sonypi_misc_fasync(-1, file, 0);
  480. down(&sonypi_device.lock);
  481. sonypi_device.open_count--;
  482. up(&sonypi_device.lock);
  483. return 0;
  484. }
  486. static int sonypi_misc_open(struct inode * inode, struct file * file) {
  487. down(&sonypi_device.lock);
  488. /* Flush input queue on first open */
  489. if (!sonypi_device.open_count)
  490. sonypi_initq();
  491. sonypi_device.open_count++;
  492. up(&sonypi_device.lock);
  493. return 0;
  494. }
  496. static ssize_t sonypi_misc_read(struct file * file, char * buf, 
  497.                 size_t count, loff_t *pos) {
  498. DECLARE_WAITQUEUE(wait, current);
  499. ssize_t i = count;
  500. unsigned char c;
  502. if (sonypi_emptyq()) {
  503. if (file->f_flags & O_NONBLOCK)
  504. return -EAGAIN;
  505. add_wait_queue(&sonypi_device.queue.proc_list, &wait);
  506. repeat:
  507. set_current_state(TASK_INTERRUPTIBLE);
  508. if (sonypi_emptyq() && !signal_pending(current)) {
  509. schedule();
  510. goto repeat;
  511. }
  512. current->state = TASK_RUNNING;
  513. remove_wait_queue(&sonypi_device.queue.proc_list, &wait);
  514. }
  515. while (i > 0 && !sonypi_emptyq()) {
  516. c = sonypi_pullq();
  517. put_user(c, buf++);
  518. i--;
  519.         }
  520. if (count - i) {
  521. file->f_dentry->d_inode->i_atime = CURRENT_TIME;
  522. return count-i;
  523. }
  524. if (signal_pending(current))
  525. return -ERESTARTSYS;
  526. return 0;
  527. }
  529. static unsigned int sonypi_misc_poll(struct file *file, poll_table * wait) {
  530. poll_wait(file, &sonypi_device.queue.proc_list, wait);
  531. if (!sonypi_emptyq())
  532. return POLLIN | POLLRDNORM;
  533. return 0;
  534. }
  536. static int sonypi_misc_ioctl(struct inode *ip, struct file *fp, 
  537.      unsigned int cmd, unsigned long arg) {
  538. int ret = 0;
  539. u8 val8;
  540. u16 val16;
  542. down(&sonypi_device.lock);
  543. switch (cmd) {
  544. case SONYPI_IOCGBRT:
  545. val8 = sonypi_ecrget(0x96);
  546. if (copy_to_user((u8 *)arg, &val8, sizeof(val8))) {
  547. ret = -EFAULT;
  548. goto out;
  549. }
  550. break;
  551. case SONYPI_IOCSBRT:
  552. if (copy_from_user(&val8, (u8 *)arg, sizeof(val8))) {
  553. ret = -EFAULT;
  554. goto out;
  555. }
  556. sonypi_ecrset(0x96, val8);
  557. break;
  558. case SONYPI_IOCGBAT1CAP:
  559. val16 = sonypi_ecrget16(0xb2);
  560. if (copy_to_user((u16 *)arg, &val16, sizeof(val16))) {
  561. ret = -EFAULT;
  562. goto out;
  563. }
  564. break;
  565. case SONYPI_IOCGBAT1REM:
  566. val16 = sonypi_ecrget16(0xa2);
  567. if (copy_to_user((u16 *)arg, &val16, sizeof(val16))) {
  568. ret = -EFAULT;
  569. goto out;
  570. }
  571. break;
  572. case SONYPI_IOCGBAT2CAP:
  573. val16 = sonypi_ecrget16(0xba);
  574. if (copy_to_user((u16 *)arg, &val16, sizeof(val16))) {
  575. ret = -EFAULT;
  576. goto out;
  577. }
  578. break;
  579. case SONYPI_IOCGBAT2REM:
  580. val16 = sonypi_ecrget16(0xaa);
  581. if (copy_to_user((u16 *)arg, &val16, sizeof(val16))) {
  582. ret = -EFAULT;
  583. goto out;
  584. }
  585. break;
  586. case SONYPI_IOCGBATFLAGS:
  587. val8 = sonypi_ecrget(0x81) & 0x07;
  588. if (copy_to_user((u8 *)arg, &val8, sizeof(val8))) {
  589. ret = -EFAULT;
  590. goto out;
  591. }
  592. break;
  593. case SONYPI_IOCGBLUE:
  594. val8 = sonypi_device.bluetooth_power;
  595. if (copy_to_user((u8 *)arg, &val8, sizeof(val8))) {
  596. ret = -EFAULT;
  597. goto out;
  598. }
  599. break;
  600. case SONYPI_IOCSBLUE:
  601. if (copy_from_user(&val8, (u8 *)arg, sizeof(val8))) {
  602. ret = -EFAULT;
  603. goto out;
  604. }
  605. sonypi_setbluetoothpower(val8);
  606. break;
  607. default:
  608. ret = -EINVAL;
  609. }
  610. out:
  611. up(&sonypi_device.lock);
  612. return ret;
  613. }
  615. static struct file_operations sonypi_misc_fops = {
  616. owner: THIS_MODULE,
  617. read: sonypi_misc_read,
  618. poll: sonypi_misc_poll,
  619. open: sonypi_misc_open,
  620. release: sonypi_misc_release,
  621. fasync:  sonypi_misc_fasync,
  622. ioctl: sonypi_misc_ioctl,
  623. };
  625. struct miscdevice sonypi_misc_device = {
  626. -1, "sonypi", &sonypi_misc_fops
  627. };
  629. static int __devinit sonypi_probe(struct pci_dev *pcidev) {
  630. int i, ret;
  631. struct sonypi_ioport_list *ioport_list;
  632. struct sonypi_irq_list *irq_list;
  634. sonypi_device.dev = pcidev;
  635. if (pcidev)
  636. sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE1;
  637. else
  638. sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE2;
  639. sonypi_initq();
  640. init_MUTEX(&sonypi_device.lock);
  641. sonypi_device.bluetooth_power = 0;
  643. if (pcidev && pci_enable_device(pcidev)) {
  644. printk(KERN_ERR "sonypi: pci_enable_device failedn");
  645. ret = -EIO;
  646. goto out1;
  647. }
  649. sonypi_misc_device.minor = (minor == -1) ? 
  650. MISC_DYNAMIC_MINOR : minor;
  651. if ((ret = misc_register(&sonypi_misc_device))) {
  652. printk(KERN_ERR "sonypi: misc_register failedn");
  653. goto out1;
  654. }
  656. if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2) {
  657. ioport_list = sonypi_type2_ioport_list;
  658. sonypi_device.region_size = SONYPI_TYPE2_REGION_SIZE;
  659. irq_list = sonypi_type2_irq_list;
  660. }
  661. else {
  662. ioport_list = sonypi_type1_ioport_list;
  663. sonypi_device.region_size = SONYPI_TYPE1_REGION_SIZE;
  664. irq_list = sonypi_type1_irq_list;
  665. }
  667. for (i = 0; ioport_list[i].port1; i++) {
  668. if (request_region(ioport_list[i].port1, 
  669.    sonypi_device.region_size, 
  670.    "Sony Programable I/O Device")) {
  671. /* get the ioport */
  672. sonypi_device.ioport1 = ioport_list[i].port1;
  673. sonypi_device.ioport2 = ioport_list[i].port2;
  674. break;
  675. }
  676. }
  677. if (!sonypi_device.ioport1) {
  678. printk(KERN_ERR "sonypi: request_region failedn");
  679. ret = -ENODEV;
  680. goto out2;
  681. }
  683. for (i = 0; irq_list[i].irq; i++) {
  684. if (!request_irq(irq_list[i].irq, sonypi_irq, 
  685.  SA_SHIRQ, "sonypi", sonypi_irq)) {
  686. sonypi_device.irq = irq_list[i].irq;
  687. sonypi_device.bits = irq_list[i].bits;
  688. break;
  689. }
  690. }
  691. if (!sonypi_device.irq ) {
  692. printk(KERN_ERR "sonypi: request_irq failedn");
  693. ret = -ENODEV;
  694. goto out3;
  695. }
  697. #if !defined(CONFIG_ACPI)
  698. /* Enable ACPI mode to get Fn key events */
  699. if (fnkeyinit)
  700. outb(0xf0, 0xb2);
  701. #endif
  703. if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2)
  704. sonypi_type2_srs();
  705. else
  706. sonypi_type1_srs();
  708. sonypi_call1(0x82);
  709. sonypi_call2(0x81, 0xff);
  710. if (compat)
  711. sonypi_call1(0x92); 
  712. else
  713. sonypi_call1(0x82);
  715. printk(KERN_INFO "sonypi: Sony Programmable I/O Controller Driver v%d.%d.n",
  716.        SONYPI_DRIVER_MAJORVERSION,
  717.        SONYPI_DRIVER_MINORVERSION);
  718. printk(KERN_INFO "sonypi: detected %s model, "
  719.        "verbose = %s, fnkeyinit = %s, camera = %s, "
  720.        "compat = %s, nojogdial = %sn",
  721.        (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE1) ?
  722. "type1" : "type2",
  723.        verbose ? "on" : "off",
  724.        fnkeyinit ? "on" : "off",
  725.        camera ? "on" : "off",
  726.        compat ? "on" : "off",
  727.        nojogdial ? "on" : "off");
  728. printk(KERN_INFO "sonypi: enabled at irq=%d, port1=0x%x, port2=0x%xn",
  729.        sonypi_device.irq, 
  730.        sonypi_device.ioport1, sonypi_device.ioport2);
  731. if (minor == -1)
  732. printk(KERN_INFO "sonypi: device allocated minor is %dn",
  733.        sonypi_misc_device.minor);
  735. return 0;
  737. out3:
  738. release_region(sonypi_device.ioport1, sonypi_device.region_size);
  739. out2:
  740. misc_deregister(&sonypi_misc_device);
  741. out1:
  742. return ret;
  743. }
  745. static void __devexit sonypi_remove(void) {
  746. sonypi_call2(0x81, 0); /* make sure we don't get any more events */
  747. if (camera)
  748. sonypi_camera_off();
  749. if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2)
  750. sonypi_type2_dis();
  751. else
  752. sonypi_type1_dis();
  753. #if !defined(CONFIG_ACPI)
  754. /* disable ACPI mode */
  755. if (fnkeyinit)
  756. outb(0xf1, 0xb2);
  757. #endif
  758. free_irq(sonypi_device.irq, sonypi_irq);
  759. release_region(sonypi_device.ioport1, sonypi_device.region_size);
  760. misc_deregister(&sonypi_misc_device);
  761. printk(KERN_INFO "sonypi: removed.n");
  762. }
  764. static int __init sonypi_init_module(void) {
  765. struct pci_dev *pcidev = NULL;
  767. if (is_sony_vaio_laptop) {
  768. pcidev = pci_find_device(PCI_VENDOR_ID_INTEL, 
  769.  PCI_DEVICE_ID_INTEL_82371AB_3, 
  770.  NULL);
  771. return sonypi_probe(pcidev);
  772. }
  773. else
  774. return -ENODEV;
  775. }
  777. static void __exit sonypi_cleanup_module(void) {
  778. sonypi_remove();
  779. }
  781. #ifndef MODULE
  782. static int __init sonypi_setup(char *str)  {
  783. int ints[7];
  785. str = get_options(str, ARRAY_SIZE(ints), ints);
  786. if (ints[0] <= 0) 
  787. goto out;
  788. minor = ints[1];
  789. if (ints[0] == 1)
  790. goto out;
  791. verbose = ints[2];
  792. if (ints[0] == 2)
  793. goto out;
  794. fnkeyinit = ints[3];
  795. if (ints[0] == 3)
  796. goto out;
  797. camera = ints[4];
  798. if (ints[0] == 4)
  799. goto out;
  800. compat = ints[5];
  801. if (ints[0] == 5)
  802. goto out;
  803. nojogdial = ints[6];
  804. out:
  805. return 1;
  806. }
  808. __setup("sonypi=", sonypi_setup);
  809. #endif /* !MODULE */
  811. /* Module entry points */
  812. module_init(sonypi_init_module);
  813. module_exit(sonypi_cleanup_module);
  815. MODULE_AUTHOR("Stelian Pop <stelian.pop@fr.alcove.com>");
  816. MODULE_DESCRIPTION("Sony Programmable I/O Control Device driver");
  817. MODULE_LICENSE("GPL");
  820. MODULE_PARM(minor,"i");
  821. MODULE_PARM_DESC(minor, "minor number of the misc device, default is -1 (automatic)");
  822. MODULE_PARM(verbose,"i");
  823. MODULE_PARM_DESC(verbose, "be verbose, default is 0 (no)");
  824. MODULE_PARM(fnkeyinit,"i");
  825. MODULE_PARM_DESC(fnkeyinit, "set this if your Fn keys do not generate any event");
  826. MODULE_PARM(camera,"i");
  827. MODULE_PARM_DESC(camera, "set this if you have a MotionEye camera (PictureBook series)");
  828. MODULE_PARM(compat,"i");
  829. MODULE_PARM_DESC(compat, "set this if you want to enable backward compatibility mode");
  830. MODULE_PARM(nojogdial, "i");
  831. MODULE_PARM_DESC(nojogdial, "set this if you have a Vaio without a jogdial (like the fx series)");
  833. EXPORT_SYMBOL(sonypi_camera_command);