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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sonypi.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：21k
源码类别：

嵌入式Linux

开发平台：

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 */
  54. /* Inits the queue */
  55. static inline void sonypi_initq(void) {
  56.         sonypi_device.queue.head = sonypi_device.queue.tail = 0;
  57. sonypi_device.queue.len = 0;
  58. sonypi_device.queue.s_lock = (spinlock_t)SPIN_LOCK_UNLOCKED;
  59. init_waitqueue_head(&sonypi_device.queue.proc_list);
  60. }
  62. /* Pulls an event from the queue */
  63. static inline unsigned char sonypi_pullq(void) {
  64.         unsigned char result;
  65. unsigned long flags;
  67. spin_lock_irqsave(&sonypi_device.queue.s_lock, flags);
  68. if (!sonypi_device.queue.len) {
  69. spin_unlock_irqrestore(&sonypi_device.queue.s_lock, flags);
  70. return 0;
  71. }
  72. result = sonypi_device.queue.buf[sonypi_device.queue.head];
  73.         sonypi_device.queue.head++;
  74. sonypi_device.queue.head &= (SONYPI_BUF_SIZE - 1);
  75. sonypi_device.queue.len--;
  76. spin_unlock_irqrestore(&sonypi_device.queue.s_lock, flags);
  77.         return result;
  78. }
  80. /* Pushes an event into the queue */
  81. static inline void sonypi_pushq(unsigned char event) {
  82. unsigned long flags;
  84. spin_lock_irqsave(&sonypi_device.queue.s_lock, flags);
  85. if (sonypi_device.queue.len == SONYPI_BUF_SIZE) {
  86. /* remove the first element */
  87.          sonypi_device.queue.head++;
  88. sonypi_device.queue.head &= (SONYPI_BUF_SIZE - 1);
  89. sonypi_device.queue.len--;
  90. }
  91. sonypi_device.queue.buf[sonypi_device.queue.tail] = event;
  92. sonypi_device.queue.tail++;
  93. sonypi_device.queue.tail &= (SONYPI_BUF_SIZE - 1);
  94. sonypi_device.queue.len++;
  96. kill_fasync(&sonypi_device.queue.fasync, SIGIO, POLL_IN);
  97. wake_up_interruptible(&sonypi_device.queue.proc_list);
  98. spin_unlock_irqrestore(&sonypi_device.queue.s_lock, flags);
  99. }
  101. /* Tests if the queue is empty */
  102. static inline int sonypi_emptyq(void) {
  103.         int result;
  104. unsigned long flags;
  106. spin_lock_irqsave(&sonypi_device.queue.s_lock, flags);
  107.         result = (sonypi_device.queue.len == 0);
  108. spin_unlock_irqrestore(&sonypi_device.queue.s_lock, flags);
  109.         return result;
  110. }
  112. static void sonypi_ecrset(u8 addr, u8 value) {
  114. wait_on_command(1, inb_p(SONYPI_CST_IOPORT) & 3);
  115. outb_p(0x81, SONYPI_CST_IOPORT);
  116. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  117. outb_p(addr, SONYPI_DATA_IOPORT);
  118. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  119. outb_p(value, SONYPI_DATA_IOPORT);
  120. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  121. }
  123. static u8 sonypi_ecrget(u8 addr) {
  125. wait_on_command(1, inb_p(SONYPI_CST_IOPORT) & 3);
  126. outb_p(0x80, SONYPI_CST_IOPORT);
  127. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  128. outb_p(addr, SONYPI_DATA_IOPORT);
  129. wait_on_command(0, inb_p(SONYPI_CST_IOPORT) & 2);
  130. return inb_p(SONYPI_DATA_IOPORT);
  131. }
  133. static u16 sonypi_ecrget16(u8 addr) {
  134. return sonypi_ecrget(addr) | (sonypi_ecrget(addr + 1) << 8);
  135. }
  137. /* Initializes the device - this comes from the AML code in the ACPI bios */
  138. static void __devinit sonypi_type1_srs(void) {
  139. u32 v;
  141. pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
  142. v = (v & 0xFFFF0000) | ((u32)sonypi_device.ioport1);
  143. pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
  145. pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
  146. v = (v & 0xFFF0FFFF) | 
  147.     (((u32)sonypi_device.ioport1 ^ sonypi_device.ioport2) << 16);
  148. pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
  150. v = inl(SONYPI_IRQ_PORT);
  151. v &= ~(((u32)0x3) << SONYPI_IRQ_SHIFT);
  152. v |= (((u32)sonypi_device.bits) << SONYPI_IRQ_SHIFT);
  153. outl(v, SONYPI_IRQ_PORT);
  155. pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
  156. v = (v & 0xFF1FFFFF) | 0x00C00000;
  157. pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
  158. }
  160. static void __devinit sonypi_type2_srs(void) {
  161. sonypi_ecrset(SONYPI_SHIB, (sonypi_device.ioport1 & 0xFF00) >> 8);
  162. sonypi_ecrset(SONYPI_SLOB,  sonypi_device.ioport1 & 0x00FF);
  163. sonypi_ecrset(SONYPI_SIRQ,  sonypi_device.bits);
  164. udelay(10);
  165. }
  167. /* Disables the device - this comes from the AML code in the ACPI bios */
  168. static void __devexit sonypi_type1_dis(void) {
  169. u32 v;
  171. pci_read_config_dword(sonypi_device.dev, SONYPI_G10A, &v);
  172. v = v & 0xFF3FFFFF;
  173. pci_write_config_dword(sonypi_device.dev, SONYPI_G10A, v);
  175. v = inl(SONYPI_IRQ_PORT);
  176. v |= (0x3 << SONYPI_IRQ_SHIFT);
  177. outl(v, SONYPI_IRQ_PORT);
  178. }
  180. static void __devexit sonypi_type2_dis(void) {
  181. sonypi_ecrset(SONYPI_SHIB, 0);
  182. sonypi_ecrset(SONYPI_SLOB, 0);
  183. sonypi_ecrset(SONYPI_SIRQ, 0);
  184. }
  186. static u8 sonypi_call1(u8 dev) {
  187. u8 v1, v2;
  189. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  190. outb(dev, sonypi_device.ioport2);
  191. v1 = inb_p(sonypi_device.ioport2);
  192. v2 = inb_p(sonypi_device.ioport1);
  193. return v2;
  194. }
  196. static u8 sonypi_call2(u8 dev, u8 fn) {
  197. u8 v1;
  199. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  200. outb(dev, sonypi_device.ioport2);
  201. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  202. outb(fn, sonypi_device.ioport1);
  203. v1 = inb_p(sonypi_device.ioport1);
  204. return v1;
  205. }
  207. static u8 sonypi_call3(u8 dev, u8 fn, u8 v) {
  208. u8 v1;
  210. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  211. outb(dev, sonypi_device.ioport2);
  212. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  213. outb(fn, sonypi_device.ioport1);
  214. wait_on_command(0, inb_p(sonypi_device.ioport2) & 2);
  215. outb(v, sonypi_device.ioport1);
  216. v1 = inb_p(sonypi_device.ioport1);
  217. return v1;
  218. }
  220. static u8 sonypi_read(u8 fn) {
  221. u8 v1, v2;
  222. int n = 100;
  224. while (n--) {
  225. v1 = sonypi_call2(0x8f, fn);
  226. v2 = sonypi_call2(0x8f, fn);
  227. if (v1 == v2 && v1 != 0xff)
  228. return v1;
  229. }
  230. return 0xff;
  231. }
  233. /* Set brightness, hue etc */
  234. static void sonypi_set(u8 fn, u8 v) {
  236. wait_on_command(0, sonypi_call3(0x90, fn, v));
  237. }
  239. /* Tests if the camera is ready */
  240. static int sonypi_camera_ready(void) {
  241. u8 v;
  243. v = sonypi_call2(0x8f, SONYPI_CAMERA_STATUS);
  244. return (v != 0xff && (v & SONYPI_CAMERA_STATUS_READY));
  245. }
  247. /* Turns the camera off */
  248. static void sonypi_camera_off(void) {
  250. sonypi_set(SONYPI_CAMERA_PICTURE, SONYPI_CAMERA_MUTE_MASK);
  252. if (!sonypi_device.camera_power)
  253. return;
  255. sonypi_call2(0x91, 0); 
  256. sonypi_device.camera_power = 0;
  257. }
  259. /* Turns the camera on */
  260. static void sonypi_camera_on(void) {
  261. int i, j;
  263. if (sonypi_device.camera_power)
  264. return;
  266. for (j = 5; j > 0; j--) {
  268. while (sonypi_call2(0x91, 0x1) != 0) {
  269. set_current_state(TASK_UNINTERRUPTIBLE);
  270. schedule_timeout(1);
  271. }
  272. sonypi_call1(0x93);
  274. for (i = 400; i > 0; i--) {
  275. if (sonypi_camera_ready())
  276. break;
  277. set_current_state(TASK_UNINTERRUPTIBLE);
  278. schedule_timeout(1);
  279. }
  280. if (i != 0)
  281. break;
  282. }
  284. if (j == 0) {
  285. printk(KERN_WARNING "sonypi: failed to power on cameran");
  286. return;
  287. }
  289. sonypi_set(0x10, 0x5a);
  290. sonypi_device.camera_power = 1;
  291. }
  293. /* sets the bluetooth subsystem power state */
  294. static void sonypi_setbluetoothpower(u8 state) {
  296. state = (state != 0);
  297. if (sonypi_device.bluetooth_power && state) 
  298. return;
  299. if (!sonypi_device.bluetooth_power && !state) 
  300. return;
  302. sonypi_call2(0x96, state);
  303. sonypi_call1(0x93);
  304. sonypi_device.bluetooth_power = state;
  305. }
  307. /* Interrupt handler: some event is available */
  308. void sonypi_irq(int irq, void *dev_id, struct pt_regs *regs) {
  309. u8 v1, v2, event = 0;
  310. int i;
  311. u8 sonypi_jogger_ev, sonypi_fnkey_ev;
  312. u8 sonypi_capture_ev, sonypi_bluetooth_ev;
  314. if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2) {
  315. sonypi_jogger_ev = SONYPI_TYPE2_JOGGER_EV;
  316. sonypi_fnkey_ev = SONYPI_TYPE2_FNKEY_EV;
  317. sonypi_capture_ev = SONYPI_TYPE2_CAPTURE_EV;
  318. sonypi_bluetooth_ev = SONYPI_TYPE2_BLUETOOTH_EV;
  319. }
  320. else {
  321. sonypi_jogger_ev = SONYPI_TYPE1_JOGGER_EV;
  322. sonypi_fnkey_ev = SONYPI_TYPE1_FNKEY_EV;
  323. sonypi_capture_ev = SONYPI_TYPE1_CAPTURE_EV;
  324. sonypi_bluetooth_ev = SONYPI_TYPE1_BLUETOOTH_EV;
  325. }
  327. v1 = inb_p(sonypi_device.ioport1);
  328. v2 = inb_p(sonypi_device.ioport2);
  330. if ((v2 & SONYPI_TYPE1_PKEY_EV) == SONYPI_TYPE1_PKEY_EV) {
  331. for (i = 0; sonypi_pkeyev[i].event; i++)
  332. if (sonypi_pkeyev[i].data == v1) {
  333. event = sonypi_pkeyev[i].event;
  334. goto found;
  335. }
  336. }
  337. if ((v2 & sonypi_jogger_ev) == sonypi_jogger_ev) {
  338. for (i = 0; sonypi_joggerev[i].event; i++)
  339. if (sonypi_joggerev[i].data == v1) {
  340. event = sonypi_joggerev[i].event;
  341. goto found;
  342. }
  343. }
  344. if ((v2 & sonypi_capture_ev) == sonypi_capture_ev) {
  345. for (i = 0; sonypi_captureev[i].event; i++)
  346. if (sonypi_captureev[i].data == v1) {
  347. event = sonypi_captureev[i].event;
  348. goto found;
  349. }
  350. }
  351. if ((v2 & sonypi_fnkey_ev) == sonypi_fnkey_ev) {
  352. for (i = 0; sonypi_fnkeyev[i].event; i++)
  353. if (sonypi_fnkeyev[i].data == v1) {
  354. event = sonypi_fnkeyev[i].event;
  355. goto found;
  356. }
  357. }
  358. if ((v2 & sonypi_bluetooth_ev) == sonypi_bluetooth_ev) {
  359. for (i = 0; sonypi_blueev[i].event; i++)
  360. if (sonypi_blueev[i].data == v1) {
  361. event = sonypi_blueev[i].event;
  362. goto found;
  363. }
  364. }
  365. if ((v2 & SONYPI_BACK_EV) == SONYPI_BACK_EV) {
  366. for (i = 0; sonypi_backev[i].event; i++)
  367. if (sonypi_backev[i].data == v1) {
  368. event = sonypi_backev[i].event;
  369. goto found;
  370. }
  371. }
  372. if ((v2 & SONYPI_LID_EV) == SONYPI_LID_EV) {
  373. for (i = 0; sonypi_lidev[i].event; i++)
  374. if (sonypi_lidev[i].data == v1) {
  375. event = sonypi_lidev[i].event;
  376. goto found;
  377. }
  378. }
  379. if (verbose)
  380. printk(KERN_WARNING 
  381.        "sonypi: unknown event port1=0x%02x,port2=0x%02xn",v1,v2);
  382. return;
  384. found:
  385. sonypi_pushq(event);
  386. }
  388. /* External camera command (exported to the motion eye v4l driver) */
  389. u8 sonypi_camera_command(int command, u8 value) {
  390. u8 ret = 0;
  392. if (!camera)
  393. return 0;
  395. down(&sonypi_device.lock);
  397. switch(command) {
  398. case SONYPI_COMMAND_GETCAMERA:
  399. ret = sonypi_camera_ready();
  400. break;
  401. case SONYPI_COMMAND_SETCAMERA:
  402. if (value)
  403. sonypi_camera_on();
  404. else
  405. sonypi_camera_off();
  406. break;
  407. case SONYPI_COMMAND_GETCAMERABRIGHTNESS:
  408. ret = sonypi_read(SONYPI_CAMERA_BRIGHTNESS);
  409. break;
  410. case SONYPI_COMMAND_SETCAMERABRIGHTNESS:
  411. sonypi_set(SONYPI_CAMERA_BRIGHTNESS, value);
  412. break;
  413. case SONYPI_COMMAND_GETCAMERACONTRAST:
  414. ret = sonypi_read(SONYPI_CAMERA_CONTRAST);
  415. break;
  416. case SONYPI_COMMAND_SETCAMERACONTRAST:
  417. sonypi_set(SONYPI_CAMERA_CONTRAST, value);
  418. break;
  419. case SONYPI_COMMAND_GETCAMERAHUE:
  420. ret = sonypi_read(SONYPI_CAMERA_HUE);
  421. break;
  422. case SONYPI_COMMAND_SETCAMERAHUE:
  423. sonypi_set(SONYPI_CAMERA_HUE, value);
  424. break;
  425. case SONYPI_COMMAND_GETCAMERACOLOR:
  426. ret = sonypi_read(SONYPI_CAMERA_COLOR);
  427. break;
  428. case SONYPI_COMMAND_SETCAMERACOLOR:
  429. sonypi_set(SONYPI_CAMERA_COLOR, value);
  430. break;
  431. case SONYPI_COMMAND_GETCAMERASHARPNESS:
  432. ret = sonypi_read(SONYPI_CAMERA_SHARPNESS);
  433. break;
  434. case SONYPI_COMMAND_SETCAMERASHARPNESS:
  435. sonypi_set(SONYPI_CAMERA_SHARPNESS, value);
  436. break;
  437. case SONYPI_COMMAND_GETCAMERAPICTURE:
  438. ret = sonypi_read(SONYPI_CAMERA_PICTURE);
  439. break;
  440. case SONYPI_COMMAND_SETCAMERAPICTURE:
  441. sonypi_set(SONYPI_CAMERA_PICTURE, value);
  442. break;
  443. case SONYPI_COMMAND_GETCAMERAAGC:
  444. ret = sonypi_read(SONYPI_CAMERA_AGC);
  445. break;
  446. case SONYPI_COMMAND_SETCAMERAAGC:
  447. sonypi_set(SONYPI_CAMERA_AGC, value);
  448. break;
  449. case SONYPI_COMMAND_GETCAMERADIRECTION:
  450. ret = sonypi_read(SONYPI_CAMERA_STATUS);
  451. ret &= SONYPI_DIRECTION_BACKWARDS;
  452. break;
  453. case SONYPI_COMMAND_GETCAMERAROMVERSION:
  454. ret = sonypi_read(SONYPI_CAMERA_ROMVERSION);
  455. break;
  456. case SONYPI_COMMAND_GETCAMERAREVISION:
  457. ret = sonypi_read(SONYPI_CAMERA_REVISION);
  458. break;
  459. }
  460. up(&sonypi_device.lock);
  461. return ret;
  462. }
  464. static int sonypi_misc_fasync(int fd, struct file *filp, int on) {
  465. int retval;
  467. retval = fasync_helper(fd, filp, on, &sonypi_device.queue.fasync);
  468. if (retval < 0)
  469. return retval;
  470. return 0;
  471. }
  473. static int sonypi_misc_release(struct inode * inode, struct file * file) {
  474. sonypi_misc_fasync(-1, file, 0);
  475. down(&sonypi_device.lock);
  476. sonypi_device.open_count--;
  477. up(&sonypi_device.lock);
  478. return 0;
  479. }
  481. static int sonypi_misc_open(struct inode * inode, struct file * file) {
  482. down(&sonypi_device.lock);
  483. if (sonypi_device.open_count)
  484. goto out;
  485. sonypi_device.open_count++;
  486. /* Flush input queue */
  487. sonypi_initq();
  488. out:
  489. up(&sonypi_device.lock);
  490. return 0;
  491. }
  493. static ssize_t sonypi_misc_read(struct file * file, char * buf, 
  494.                 size_t count, loff_t *pos) {
  495. DECLARE_WAITQUEUE(wait, current);
  496. ssize_t i = count;
  497. unsigned char c;
  499. if (sonypi_emptyq()) {
  500. if (file->f_flags & O_NONBLOCK)
  501. return -EAGAIN;
  502. add_wait_queue(&sonypi_device.queue.proc_list, &wait);
  503. repeat:
  504. set_current_state(TASK_INTERRUPTIBLE);
  505. if (sonypi_emptyq() && !signal_pending(current)) {
  506. schedule();
  507. goto repeat;
  508. }
  509. current->state = TASK_RUNNING;
  510. remove_wait_queue(&sonypi_device.queue.proc_list, &wait);
  511. }
  512. while (i > 0 && !sonypi_emptyq()) {
  513. c = sonypi_pullq();
  514. put_user(c, buf++);
  515. i--;
  516.         }
  517. if (count - i) {
  518. file->f_dentry->d_inode->i_atime = CURRENT_TIME;
  519. return count-i;
  520. }
  521. if (signal_pending(current))
  522. return -ERESTARTSYS;
  523. return 0;
  524. }
  526. static unsigned int sonypi_misc_poll(struct file *file, poll_table * wait) {
  527. poll_wait(file, &sonypi_device.queue.proc_list, wait);
  528. if (!sonypi_emptyq())
  529. return POLLIN | POLLRDNORM;
  530. return 0;
  531. }
  533. static int sonypi_misc_ioctl(struct inode *ip, struct file *fp, 
  534.      unsigned int cmd, unsigned long arg) {
  535. int ret = 0;
  536. u8 val8;
  537. u16 val16;
  539. down(&sonypi_device.lock);
  540. switch (cmd) {
  541. case SONYPI_IOCGBRT:
  542. val8 = sonypi_ecrget(0x96);
  543. if (copy_to_user((u8 *)arg, &val8, sizeof(val8))) {
  544. ret = -EFAULT;
  545. goto out;
  546. }
  547. break;
  548. case SONYPI_IOCSBRT:
  549. if (copy_from_user(&val8, (u8 *)arg, sizeof(val8))) {
  550. ret = -EFAULT;
  551. goto out;
  552. }
  553. sonypi_ecrset(0x96, val8);
  554. break;
  555. case SONYPI_IOCGBAT1CAP:
  556. val16 = sonypi_ecrget16(0xb2);
  557. if (copy_to_user((u16 *)arg, &val16, sizeof(val16))) {
  558. ret = -EFAULT;
  559. goto out;
  560. }
  561. break;
  562. case SONYPI_IOCGBAT1REM:
  563. val16 = sonypi_ecrget16(0xa2);
  564. if (copy_to_user((u16 *)arg, &val16, sizeof(val16))) {
  565. ret = -EFAULT;
  566. goto out;
  567. }
  568. break;
  569. case SONYPI_IOCGBAT2CAP:
  570. val16 = sonypi_ecrget16(0xba);
  571. if (copy_to_user((u16 *)arg, &val16, sizeof(val16))) {
  572. ret = -EFAULT;
  573. goto out;
  574. }
  575. break;
  576. case SONYPI_IOCGBAT2REM:
  577. val16 = sonypi_ecrget16(0xaa);
  578. if (copy_to_user((u16 *)arg, &val16, sizeof(val16))) {
  579. ret = -EFAULT;
  580. goto out;
  581. }
  582. break;
  583. case SONYPI_IOCGBATFLAGS:
  584. val8 = sonypi_ecrget(0x81) & 0x07;
  585. if (copy_to_user((u8 *)arg, &val8, sizeof(val8))) {
  586. ret = -EFAULT;
  587. goto out;
  588. }
  589. break;
  590. case SONYPI_IOCGBLUE:
  591. val8 = sonypi_device.bluetooth_power;
  592. if (copy_to_user((u8 *)arg, &val8, sizeof(val8))) {
  593. ret = -EFAULT;
  594. goto out;
  595. }
  596. break;
  597. case SONYPI_IOCSBLUE:
  598. if (copy_from_user(&val8, (u8 *)arg, sizeof(val8))) {
  599. ret = -EFAULT;
  600. goto out;
  601. }
  602. sonypi_setbluetoothpower(val8);
  603. break;
  604. default:
  605. ret = -EINVAL;
  606. }
  607. out:
  608. up(&sonypi_device.lock);
  609. return ret;
  610. }
  612. static struct file_operations sonypi_misc_fops = {
  613. owner: THIS_MODULE,
  614. read: sonypi_misc_read,
  615. poll: sonypi_misc_poll,
  616. open: sonypi_misc_open,
  617. release: sonypi_misc_release,
  618. fasync:  sonypi_misc_fasync,
  619. ioctl: sonypi_misc_ioctl,
  620. };
  622. struct miscdevice sonypi_misc_device = {
  623. -1, "sonypi", &sonypi_misc_fops
  624. };
  626. static int __devinit sonypi_probe(struct pci_dev *pcidev) {
  627. int i, ret;
  628. struct sonypi_ioport_list *ioport_list;
  629. struct sonypi_irq_list *irq_list;
  631. sonypi_device.dev = pcidev;
  632. if (pcidev)
  633. sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE1;
  634. else
  635. sonypi_device.model = SONYPI_DEVICE_MODEL_TYPE2;
  636. sonypi_initq();
  637. init_MUTEX(&sonypi_device.lock);
  638. sonypi_device.bluetooth_power = 0;
  640. if (pcidev && pci_enable_device(pcidev)) {
  641. printk(KERN_ERR "sonypi: pci_enable_device failedn");
  642. ret = -EIO;
  643. goto out1;
  644. }
  646. sonypi_misc_device.minor = (minor == -1) ? 
  647. MISC_DYNAMIC_MINOR : minor;
  648. if ((ret = misc_register(&sonypi_misc_device))) {
  649. printk(KERN_ERR "sonypi: misc_register failedn");
  650. goto out1;
  651. }
  653. if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2) {
  654. ioport_list = sonypi_type2_ioport_list;
  655. sonypi_device.region_size = SONYPI_TYPE2_REGION_SIZE;
  656. irq_list = sonypi_type2_irq_list;
  657. }
  658. else {
  659. ioport_list = sonypi_type1_ioport_list;
  660. sonypi_device.region_size = SONYPI_TYPE1_REGION_SIZE;
  661. irq_list = sonypi_type1_irq_list;
  662. }
  664. for (i = 0; ioport_list[i].port1; i++) {
  665. if (request_region(ioport_list[i].port1, 
  666.    sonypi_device.region_size, 
  667.    "Sony Programable I/O Device")) {
  668. /* get the ioport */
  669. sonypi_device.ioport1 = ioport_list[i].port1;
  670. sonypi_device.ioport2 = ioport_list[i].port2;
  671. break;
  672. }
  673. }
  674. if (!sonypi_device.ioport1) {
  675. printk(KERN_ERR "sonypi: request_region failedn");
  676. ret = -ENODEV;
  677. goto out2;
  678. }
  680. for (i = 0; irq_list[i].irq; i++) {
  681. if (!request_irq(irq_list[i].irq, sonypi_irq, 
  682.  SA_SHIRQ, "sonypi", sonypi_irq)) {
  683. sonypi_device.irq = irq_list[i].irq;
  684. sonypi_device.bits = irq_list[i].bits;
  685. break;
  686. }
  687. }
  688. if (!sonypi_device.irq ) {
  689. printk(KERN_ERR "sonypi: request_irq failedn");
  690. ret = -ENODEV;
  691. goto out3;
  692. }
  694. #if !defined(CONFIG_ACPI)
  695. /* Enable ACPI mode to get Fn key events */
  696. if (fnkeyinit)
  697. outb(0xf0, 0xb2);
  698. #endif
  700. if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2)
  701. sonypi_type2_srs();
  702. else
  703. sonypi_type1_srs();
  705. sonypi_call1(0x82);
  706. sonypi_call2(0x81, 0xff);
  707. if (compat)
  708. sonypi_call1(0x92); 
  709. else
  710. sonypi_call1(0x82);
  712. printk(KERN_INFO "sonypi: Sony Programmable I/O Controller Driver v%d.%d.n",
  713.        SONYPI_DRIVER_MAJORVERSION,
  714.        SONYPI_DRIVER_MINORVERSION);
  715. printk(KERN_INFO "sonypi: detected %s model, "
  716.        "camera = %s, compat = %sn",
  717.        (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE1) ?
  718. "type1" : "type2",
  719.        camera ? "on" : "off",
  720.        compat ? "on" : "off");
  721. printk(KERN_INFO "sonypi: enabled at irq=%d, port1=0x%x, port2=0x%xn",
  722.        sonypi_device.irq, 
  723.        sonypi_device.ioport1, sonypi_device.ioport2);
  724. if (minor == -1)
  725. printk(KERN_INFO "sonypi: device allocated minor is %dn",
  726.        sonypi_misc_device.minor);
  728. return 0;
  730. out3:
  731. release_region(sonypi_device.ioport1, sonypi_device.region_size);
  732. out2:
  733. misc_deregister(&sonypi_misc_device);
  734. out1:
  735. return ret;
  736. }
  738. static void __devexit sonypi_remove(void) {
  739. sonypi_call2(0x81, 0); /* make sure we don't get any more events */
  740. if (camera)
  741. sonypi_camera_off();
  742. if (sonypi_device.model == SONYPI_DEVICE_MODEL_TYPE2)
  743. sonypi_type2_dis();
  744. else
  745. sonypi_type1_dis();
  746. #if !defined(CONFIG_ACPI)
  747. /* disable ACPI mode */
  748. if (fnkeyinit)
  749. outb(0xf1, 0xb2);
  750. #endif
  751. free_irq(sonypi_device.irq, sonypi_irq);
  752. release_region(sonypi_device.ioport1, sonypi_device.region_size);
  753. misc_deregister(&sonypi_misc_device);
  754. printk(KERN_INFO "sonypi: removed.n");
  755. }
  757. static int __init sonypi_init_module(void) {
  758. struct pci_dev *pcidev = NULL;
  760. if (is_sony_vaio_laptop) {
  761. pcidev = pci_find_device(PCI_VENDOR_ID_INTEL, 
  762.  PCI_DEVICE_ID_INTEL_82371AB_3, 
  763.  NULL);
  764. return sonypi_probe(pcidev);
  765. }
  766. else
  767. return -ENODEV;
  768. }
  770. static void __exit sonypi_cleanup_module(void) {
  771. sonypi_remove();
  772. }
  774. #ifndef MODULE
  775. static int __init sonypi_setup(char *str)  {
  776. int ints[6];
  778. str = get_options(str, ARRAY_SIZE(ints), ints);
  779. if (ints[0] <= 0) 
  780. goto out;
  781. minor = ints[1];
  782. if (ints[0] == 1)
  783. goto out;
  784. verbose = ints[2];
  785. if (ints[0] == 2)
  786. goto out;
  787. fnkeyinit = ints[3];
  788. if (ints[0] == 3)
  789. goto out;
  790. camera = ints[4];
  791. if (ints[0] == 4)
  792. goto out;
  793. compat = ints[5];
  794. out:
  795. return 1;
  796. }
  798. __setup("sonypi=", sonypi_setup);
  799. #endif /* !MODULE */
  801. /* Module entry points */
  802. module_init(sonypi_init_module);
  803. module_exit(sonypi_cleanup_module);
  805. MODULE_AUTHOR("Stelian Pop <stelian.pop@fr.alcove.com>");
  806. MODULE_DESCRIPTION("Sony Programmable I/O Control Device driver");
  807. MODULE_LICENSE("GPL");
  810. MODULE_PARM(minor,"i");
  811. MODULE_PARM_DESC(minor, "minor number of the misc device, default is -1 (automatic)");
  812. MODULE_PARM(verbose,"i");
  813. MODULE_PARM_DESC(verbose, "be verbose, default is 0 (no)");
  814. MODULE_PARM(fnkeyinit,"i");
  815. MODULE_PARM_DESC(fnkeyinit, "set this if your Fn keys do not generate any event");
  816. MODULE_PARM(camera,"i");
  817. MODULE_PARM_DESC(camera, "set this if you have a MotionEye camera (PictureBook series)");
  818. MODULE_PARM(compat,"i");
  819. MODULE_PARM_DESC(compat, "set this if you want to enable backward compatibility mode");
  821. EXPORT_SYMBOL(sonypi_camera_command);