drivers/media/dvb/dvb-usb/opera1.c

   1 /* DVB USB framework compliant Linux driver for the Opera1 DVB-S Card
   2 *
   3 * Copyright (C) 2006 Mario Hlawitschka (dh1pa@amsat.org)
   4 * Copyright (C) 2006 Marco Gittler (g.marco@freenet.de)
   5 *
   6 *       This program is free software; you can redistribute it and/or modify it
   7 *       under the terms of the GNU General Public License as published by the Free
   8 *       Software Foundation, version 2.
   9 *
  10 * see Documentation/dvb/README.dvb-usb for more information
  11 */
  12
  13 #define DVB_USB_LOG_PREFIX "opera"
  14
  15 #include "dvb-usb.h"
  16 #include "stv0299.h"
  17
  18 #define OPERA_READ_MSG 0
  19 #define OPERA_WRITE_MSG 1
  20 #define OPERA_I2C_TUNER 0xd1
  21
  22 #define READ_FX2_REG_REQ  0xba
  23 #define READ_MAC_ADDR 0x08
  24 #define OPERA_WRITE_FX2 0xbb
  25 #define OPERA_TUNER_REQ 0xb1
  26 #define REG_1F_SYMBOLRATE_BYTE0 0x1f
  27 #define REG_20_SYMBOLRATE_BYTE1 0x20
  28 #define REG_21_SYMBOLRATE_BYTE2 0x21
  29
  30 #define ADDR_B600_VOLTAGE_13V (0x02)
  31 #define ADDR_B601_VOLTAGE_18V (0x03)
  32 #define ADDR_B1A6_STREAM_CTRL (0x04)
  33 #define ADDR_B880_READ_REMOTE (0x05)
  34
  35 struct opera1_state {
  36         u32 last_key_pressed;
  37 };
  38 struct rc_map_opera_table {
  39         u32 keycode;
  40         u32 event;
  41 };
  42
  43 static int dvb_usb_opera1_debug;
  44 module_param_named(debug, dvb_usb_opera1_debug, int, 0644);
  45 MODULE_PARM_DESC(debug,
  46                  "set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64 (or-able))."
  47                  DVB_USB_DEBUG_STATUS);
  48
  49 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  50
  51
  52 static int opera1_xilinx_rw(struct usb_device *dev, u8 request, u16 value,
  53                             u8 * data, u16 len, int flags)
  54 {
  55         int ret;
  56         u8 tmp;
  57         u8 *buf;
  58         unsigned int pipe = (flags == OPERA_READ_MSG) ?
  59                 usb_rcvctrlpipe(dev,0) : usb_sndctrlpipe(dev, 0);
  60         u8 request_type = (flags == OPERA_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT;
  61
  62         buf = kmalloc(len, GFP_KERNEL);
  63         if (!buf)
  64                 return -ENOMEM;
  65
  66         if (flags == OPERA_WRITE_MSG)
  67                 memcpy(buf, data, len);
  68         ret = usb_control_msg(dev, pipe, request,
  69                         request_type | USB_TYPE_VENDOR, value, 0x0,
  70                         buf, len, 2000);
  71
  72         if (request == OPERA_TUNER_REQ) {
  73                 tmp = buf[0];
  74                 if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  75                             OPERA_TUNER_REQ, USB_DIR_IN | USB_TYPE_VENDOR,
  76                             0x01, 0x0, buf, 1, 2000) < 1 || buf[0] != 0x08) {
  77                         ret = 0;
  78                         goto out;
  79                 }
  80                 buf[0] = tmp;
  81         }
  82         if (flags == OPERA_READ_MSG)
  83                 memcpy(data, buf, len);
  84 out:
  85         kfree(buf);
  86         return ret;
  87 }
  88
  89 /* I2C */
  90
  91 static int opera1_usb_i2c_msgxfer(struct dvb_usb_device *dev, u16 addr,
  92                                   u8 * buf, u16 len)
  93 {
  94         int ret = 0;
  95         u8 request;
  96         u16 value;
  97
  98         if (!dev) {
  99                 info("no usb_device");
 100                 return -EINVAL;
 101         }
 102         if (mutex_lock_interruptible(&dev->usb_mutex) < 0)
 103                 return -EAGAIN;
 104
 105         switch (addr>>1){
 106                 case ADDR_B600_VOLTAGE_13V:
 107                         request=0xb6;
 108                         value=0x00;
 109                         break;
 110                 case ADDR_B601_VOLTAGE_18V:
 111                         request=0xb6;
 112                         value=0x01;
 113                         break;
 114                 case ADDR_B1A6_STREAM_CTRL:
 115                         request=0xb1;
 116                         value=0xa6;
 117                         break;
 118                 case ADDR_B880_READ_REMOTE:
 119                         request=0xb8;
 120                         value=0x80;
 121                         break;
 122                 default:
 123                         request=0xb1;
 124                         value=addr;
 125         }
 126         ret = opera1_xilinx_rw(dev->udev, request,
 127                 value, buf, len,
 128                 addr&0x01?OPERA_READ_MSG:OPERA_WRITE_MSG);
 129
 130         mutex_unlock(&dev->usb_mutex);
 131         return ret;
 132 }
 133
 134 static int opera1_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 135                            int num)
 136 {
 137         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 138         int i = 0, tmp = 0;
 139
 140         if (!d)
 141                 return -ENODEV;
 142         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 143                 return -EAGAIN;
 144
 145         for (i = 0; i < num; i++) {
 146                 if ((tmp = opera1_usb_i2c_msgxfer(d,
 147                                         (msg[i].addr<<1)|(msg[i].flags&I2C_M_RD?0x01:0),
 148                                         msg[i].buf,
 149                                         msg[i].len
 150                                         )) != msg[i].len) {
 151                         break;
 152                 }
 153                 if (dvb_usb_opera1_debug & 0x10)
 154                         info("sending i2c mesage %d %d", tmp, msg[i].len);
 155         }
 156         mutex_unlock(&d->i2c_mutex);
 157         return num;
 158 }
 159
 160 static u32 opera1_i2c_func(struct i2c_adapter *adapter)
 161 {
 162         return I2C_FUNC_I2C;
 163 }
 164
 165 static struct i2c_algorithm opera1_i2c_algo = {
 166         .master_xfer = opera1_i2c_xfer,
 167         .functionality = opera1_i2c_func,
 168 };
 169
 170 static int opera1_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
 171 {
 172         static u8 command_13v[1]={0x00};
 173         static u8 command_18v[1]={0x01};
 174         struct i2c_msg msg[] = {
 175                 {.addr = ADDR_B600_VOLTAGE_13V,.flags = 0,.buf = command_13v,.len = 1},
 176         };
 177         struct dvb_usb_adapter *udev_adap =
 178             (struct dvb_usb_adapter *)(fe->dvb->priv);
 179         if (voltage == SEC_VOLTAGE_18) {
 180                 msg[0].addr = ADDR_B601_VOLTAGE_18V;
 181                 msg[0].buf = command_18v;
 182         }
 183         i2c_transfer(&udev_adap->dev->i2c_adap, msg, 1);
 184         return 0;
 185 }
 186
 187 static int opera1_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate,
 188                                           u32 ratio)
 189 {
 190         stv0299_writereg(fe, 0x13, 0x98);
 191         stv0299_writereg(fe, 0x14, 0x95);
 192         stv0299_writereg(fe, REG_1F_SYMBOLRATE_BYTE0, (ratio >> 16) & 0xff);
 193         stv0299_writereg(fe, REG_20_SYMBOLRATE_BYTE1, (ratio >> 8) & 0xff);
 194         stv0299_writereg(fe, REG_21_SYMBOLRATE_BYTE2, (ratio) & 0xf0);
 195         return 0;
 196
 197 }
 198 static u8 opera1_inittab[] = {
 199         0x00, 0xa1,
 200         0x01, 0x15,
 201         0x02, 0x30,
 202         0x03, 0x00,
 203         0x04, 0x7d,
 204         0x05, 0x05,
 205         0x06, 0x02,
 206         0x07, 0x00,
 207         0x0b, 0x00,
 208         0x0c, 0x01,
 209         0x0d, 0x81,
 210         0x0e, 0x44,
 211         0x0f, 0x19,
 212         0x10, 0x3f,
 213         0x11, 0x84,
 214         0x12, 0xda,
 215         0x13, 0x98,
 216         0x14, 0x95,
 217         0x15, 0xc9,
 218         0x16, 0xeb,
 219         0x17, 0x00,
 220         0x18, 0x19,
 221         0x19, 0x8b,
 222         0x1a, 0x00,
 223         0x1b, 0x82,
 224         0x1c, 0x7f,
 225         0x1d, 0x00,
 226         0x1e, 0x00,
 227         REG_1F_SYMBOLRATE_BYTE0, 0x06,
 228         REG_20_SYMBOLRATE_BYTE1, 0x50,
 229         REG_21_SYMBOLRATE_BYTE2, 0x10,
 230         0x22, 0x00,
 231         0x23, 0x00,
 232         0x24, 0x37,
 233         0x25, 0xbc,
 234         0x26, 0x00,
 235         0x27, 0x00,
 236         0x28, 0x00,
 237         0x29, 0x1e,
 238         0x2a, 0x14,
 239         0x2b, 0x1f,
 240         0x2c, 0x09,
 241         0x2d, 0x0a,
 242         0x2e, 0x00,
 243         0x2f, 0x00,
 244         0x30, 0x00,
 245         0x31, 0x1f,
 246         0x32, 0x19,
 247         0x33, 0xfc,
 248         0x34, 0x13,
 249         0xff, 0xff,
 250 };
 251
 252 static struct stv0299_config opera1_stv0299_config = {
 253         .demod_address = 0xd0>>1,
 254         .min_delay_ms = 100,
 255         .mclk = 88000000UL,
 256         .invert = 1,
 257         .skip_reinit = 0,
 258         .lock_output = STV0299_LOCKOUTPUT_0,
 259         .volt13_op0_op1 = STV0299_VOLT13_OP0,
 260         .inittab = opera1_inittab,
 261         .set_symbol_rate = opera1_stv0299_set_symbol_rate,
 262 };
 263
 264 static int opera1_frontend_attach(struct dvb_usb_adapter *d)
 265 {
 266         if ((d->fe =
 267              dvb_attach(stv0299_attach, &opera1_stv0299_config,
 268                         &d->dev->i2c_adap)) != NULL) {
 269                 d->fe->ops.set_voltage = opera1_set_voltage;
 270                 return 0;
 271         }
 272         info("not attached stv0299");
 273         return -EIO;
 274 }
 275
 276 static int opera1_tuner_attach(struct dvb_usb_adapter *adap)
 277 {
 278         dvb_attach(
 279                 dvb_pll_attach, adap->fe, 0xc0>>1,
 280                 &adap->dev->i2c_adap, DVB_PLL_OPERA1
 281         );
 282         return 0;
 283 }
 284
 285 static int opera1_power_ctrl(struct dvb_usb_device *d, int onoff)
 286 {
 287         u8 val = onoff ? 0x01 : 0x00;
 288
 289         if (dvb_usb_opera1_debug)
 290                 info("power %s", onoff ? "on" : "off");
 291         return opera1_xilinx_rw(d->udev, 0xb7, val,
 292                                 &val, 1, OPERA_WRITE_MSG);
 293 }
 294
 295 static int opera1_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
 296 {
 297         static u8 buf_start[2] = { 0xff, 0x03 };
 298         static u8 buf_stop[2] = { 0xff, 0x00 };
 299         struct i2c_msg start_tuner[] = {
 300                 {.addr = ADDR_B1A6_STREAM_CTRL,.buf = onoff ? buf_start : buf_stop,.len = 2},
 301         };
 302         if (dvb_usb_opera1_debug)
 303                 info("streaming %s", onoff ? "on" : "off");
 304         i2c_transfer(&adap->dev->i2c_adap, start_tuner, 1);
 305         return 0;
 306 }
 307
 308 static int opera1_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
 309                              int onoff)
 310 {
 311         u8 b_pid[3];
 312         struct i2c_msg msg[] = {
 313                 {.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
 314         };
 315         if (dvb_usb_opera1_debug)
 316                 info("pidfilter index: %d pid: %d %s", index, pid,
 317                         onoff ? "on" : "off");
 318         b_pid[0] = (2 * index) + 4;
 319         b_pid[1] = onoff ? (pid & 0xff) : (0x00);
 320         b_pid[2] = onoff ? ((pid >> 8) & 0xff) : (0x00);
 321         i2c_transfer(&adap->dev->i2c_adap, msg, 1);
 322         return 0;
 323 }
 324
 325 static int opera1_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
 326 {
 327         int u = 0x04;
 328         u8 b_pid[3];
 329         struct i2c_msg msg[] = {
 330                 {.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
 331         };
 332         if (dvb_usb_opera1_debug)
 333                 info("%s hw-pidfilter", onoff ? "enable" : "disable");
 334         for (; u < 0x7e; u += 2) {
 335                 b_pid[0] = u;
 336                 b_pid[1] = 0;
 337                 b_pid[2] = 0x80;
 338                 i2c_transfer(&adap->dev->i2c_adap, msg, 1);
 339         }
 340         return 0;
 341 }
 342
 343 static struct rc_map_table rc_map_opera1_table[] = {
 344         {0x5fa0, KEY_1},
 345         {0x51af, KEY_2},
 346         {0x5da2, KEY_3},
 347         {0x41be, KEY_4},
 348         {0x0bf5, KEY_5},
 349         {0x43bd, KEY_6},
 350         {0x47b8, KEY_7},
 351         {0x49b6, KEY_8},
 352         {0x05fa, KEY_9},
 353         {0x45ba, KEY_0},
 354         {0x09f6, KEY_CHANNELUP},        /*chanup */
 355         {0x1be5, KEY_CHANNELDOWN},      /*chandown */
 356         {0x5da3, KEY_VOLUMEDOWN},       /*voldown */
 357         {0x5fa1, KEY_VOLUMEUP},         /*volup */
 358         {0x07f8, KEY_SPACE},            /*tab */
 359         {0x1fe1, KEY_OK},               /*play ok */
 360         {0x1be4, KEY_ZOOM},             /*zoom */
 361         {0x59a6, KEY_MUTE},             /*mute */
 362         {0x5ba5, KEY_RADIO},            /*tv/f */
 363         {0x19e7, KEY_RECORD},           /*rec */
 364         {0x01fe, KEY_STOP},             /*Stop */
 365         {0x03fd, KEY_PAUSE},            /*pause */
 366         {0x03fc, KEY_SCREEN},           /*<- -> */
 367         {0x07f9, KEY_CAMERA},           /*capture */
 368         {0x47b9, KEY_ESC},              /*exit */
 369         {0x43bc, KEY_POWER2},           /*power */
 370 };
 371
 372 static int opera1_rc_query(struct dvb_usb_device *dev, u32 * event, int *state)
 373 {
 374         struct opera1_state *opst = dev->priv;
 375         u8 rcbuffer[32];
 376         const u16 startmarker1 = 0x10ed;
 377         const u16 startmarker2 = 0x11ec;
 378         struct i2c_msg read_remote[] = {
 379                 {.addr = ADDR_B880_READ_REMOTE,.buf = rcbuffer,.flags = I2C_M_RD,.len = 32},
 380         };
 381         int i = 0;
 382         u32 send_key = 0;
 383
 384         if (i2c_transfer(&dev->i2c_adap, read_remote, 1) == 1) {
 385                 for (i = 0; i < 32; i++) {
 386                         if (rcbuffer[i])
 387                                 send_key |= 1;
 388                         if (i < 31)
 389                                 send_key = send_key << 1;
 390                 }
 391                 if (send_key & 0x8000)
 392                         send_key = (send_key << 1) | (send_key >> 15 & 0x01);
 393
 394                 if (send_key == 0xffff && opst->last_key_pressed != 0) {
 395                         *state = REMOTE_KEY_REPEAT;
 396                         *event = opst->last_key_pressed;
 397                         return 0;
 398                 }
 399                 for (; send_key != 0;) {
 400                         if (send_key >> 16 == startmarker2) {
 401                                 break;
 402                         } else if (send_key >> 16 == startmarker1) {
 403                                 send_key =
 404                                         (send_key & 0xfffeffff) | (startmarker1 << 16);
 405                                 break;
 406                         } else
 407                                 send_key >>= 1;
 408                 }
 409
 410                 if (send_key == 0)
 411                         return 0;
 412
 413                 send_key = (send_key & 0xffff) | 0x0100;
 414
 415                 for (i = 0; i < ARRAY_SIZE(rc_map_opera1_table); i++) {
 416                         if (rc5_scan(&rc_map_opera1_table[i]) == (send_key & 0xffff)) {
 417                                 *state = REMOTE_KEY_PRESSED;
 418                                 *event = rc_map_opera1_table[i].keycode;
 419                                 opst->last_key_pressed =
 420                                         rc_map_opera1_table[i].keycode;
 421                                 break;
 422                         }
 423                         opst->last_key_pressed = 0;
 424                 }
 425         } else
 426                 *state = REMOTE_NO_KEY_PRESSED;
 427         return 0;
 428 }
 429
 430 static struct usb_device_id opera1_table[] = {
 431         {USB_DEVICE(USB_VID_CYPRESS, USB_PID_OPERA1_COLD)},
 432         {USB_DEVICE(USB_VID_OPERA1, USB_PID_OPERA1_WARM)},
 433         {}
 434 };
 435
 436 MODULE_DEVICE_TABLE(usb, opera1_table);
 437
 438 static int opera1_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
 439 {
 440         u8 command[] = { READ_MAC_ADDR };
 441         opera1_xilinx_rw(d->udev, 0xb1, 0xa0, command, 1, OPERA_WRITE_MSG);
 442         opera1_xilinx_rw(d->udev, 0xb1, 0xa1, mac, 6, OPERA_READ_MSG);
 443         return 0;
 444 }
 445 static int opera1_xilinx_load_firmware(struct usb_device *dev,
 446                                        const char *filename)
 447 {
 448         const struct firmware *fw = NULL;
 449         u8 *b, *p;
 450         int ret = 0, i,fpgasize=40;
 451         u8 testval;
 452         info("start downloading fpga firmware %s",filename);
 453
 454         if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) {
 455                 err("did not find the firmware file. (%s) "
 456                         "Please see linux/Documentation/dvb/ for more details on firmware-problems.",
 457                         filename);
 458                 return ret;
 459         } else {
 460                 p = kmalloc(fw->size, GFP_KERNEL);
 461                 opera1_xilinx_rw(dev, 0xbc, 0x00, &testval, 1, OPERA_READ_MSG);
 462                 if (p != NULL && testval != 0x67) {
 463
 464                         u8 reset = 0, fpga_command = 0;
 465                         memcpy(p, fw->data, fw->size);
 466                         /* clear fpga ? */
 467                         opera1_xilinx_rw(dev, 0xbc, 0xaa, &fpga_command, 1,
 468                                          OPERA_WRITE_MSG);
 469                         for (i = 0; i < fw->size;) {
 470                                 if ( (fw->size - i) <fpgasize){
 471                                     fpgasize=fw->size-i;
 472                                 }
 473                                 b = (u8 *) p + i;
 474                                 if (opera1_xilinx_rw
 475                                         (dev, OPERA_WRITE_FX2, 0x0, b , fpgasize,
 476                                                 OPERA_WRITE_MSG) != fpgasize
 477                                         ) {
 478                                         err("error while transferring firmware");
 479                                         ret = -EINVAL;
 480                                         break;
 481                                 }
 482                                 i = i + fpgasize;
 483                         }
 484                         /* restart the CPU */
 485                         if (ret || opera1_xilinx_rw
 486                                         (dev, 0xa0, 0xe600, &reset, 1,
 487                                         OPERA_WRITE_MSG) != 1) {
 488                                 err("could not restart the USB controller CPU.");
 489                                 ret = -EINVAL;
 490                         }
 491                 }
 492         }
 493         kfree(p);
 494         release_firmware(fw);
 495         return ret;
 496 }
 497
 498 static struct dvb_usb_device_properties opera1_properties = {
 499         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 500         .usb_ctrl = CYPRESS_FX2,
 501         .firmware = "dvb-usb-opera-01.fw",
 502         .size_of_priv = sizeof(struct opera1_state),
 503
 504         .power_ctrl = opera1_power_ctrl,
 505         .i2c_algo = &opera1_i2c_algo,
 506
 507         .rc.legacy = {
 508                 .rc_map_table = rc_map_opera1_table,
 509                 .rc_map_size = ARRAY_SIZE(rc_map_opera1_table),
 510                 .rc_interval = 200,
 511                 .rc_query = opera1_rc_query,
 512         },
 513         .read_mac_address = opera1_read_mac_address,
 514         .generic_bulk_ctrl_endpoint = 0x00,
 515         /* parameter for the MPEG2-data transfer */
 516         .num_adapters = 1,
 517         .adapter = {
 518                 {
 519                         .frontend_attach = opera1_frontend_attach,
 520                         .streaming_ctrl = opera1_streaming_ctrl,
 521                         .tuner_attach = opera1_tuner_attach,
 522                         .caps =
 523                                 DVB_USB_ADAP_HAS_PID_FILTER |
 524                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
 525                         .pid_filter = opera1_pid_filter,
 526                         .pid_filter_ctrl = opera1_pid_filter_control,
 527                         .pid_filter_count = 252,
 528                         .stream = {
 529                                 .type = USB_BULK,
 530                                 .count = 10,
 531                                 .endpoint = 0x82,
 532                                 .u = {
 533                                         .bulk = {
 534                                                 .buffersize = 4096,
 535                                         }
 536                                 }
 537                         },
 538                 }
 539         },
 540         .num_device_descs = 1,
 541         .devices = {
 542                 {"Opera1 DVB-S USB2.0",
 543                         {&opera1_table[0], NULL},
 544                         {&opera1_table[1], NULL},
 545                 },
 546         }
 547 };
 548
 549 static int opera1_probe(struct usb_interface *intf,
 550                         const struct usb_device_id *id)
 551 {
 552         struct usb_device *udev = interface_to_usbdev(intf);
 553
 554         if (udev->descriptor.idProduct == USB_PID_OPERA1_WARM &&
 555                 udev->descriptor.idVendor == USB_VID_OPERA1 &&
 556                 opera1_xilinx_load_firmware(udev, "dvb-usb-opera1-fpga-01.fw") != 0
 557             ) {
 558                 return -EINVAL;
 559         }
 560
 561         if (0 != dvb_usb_device_init(intf, &opera1_properties,
 562                                      THIS_MODULE, NULL, adapter_nr))
 563                 return -EINVAL;
 564         return 0;
 565 }
 566
 567 static struct usb_driver opera1_driver = {
 568         .name = "opera1",
 569         .probe = opera1_probe,
 570         .disconnect = dvb_usb_device_exit,
 571         .id_table = opera1_table,
 572 };
 573
 574 static int __init opera1_module_init(void)
 575 {
 576         int result = 0;
 577         if ((result = usb_register(&opera1_driver))) {
 578                 err("usb_register failed. Error number %d", result);
 579         }
 580         return result;
 581 }
 582
 583 static void __exit opera1_module_exit(void)
 584 {
 585         usb_deregister(&opera1_driver);
 586 }
 587
 588 module_init(opera1_module_init);
 589 module_exit(opera1_module_exit);
 590
 591 MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org");
 592 MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de");
 593 MODULE_DESCRIPTION("Driver for Opera1 DVB-S device");
 594 MODULE_VERSION("0.1");
 595 MODULE_LICENSE("GPL");