drivers/media/video/gspca/pac207.c

   1 /*
   2  * Pixart PAC207BCA library
   3  *
   4  * Copyright (C) 2008 Hans de Goede <j.w.r.degoede@hhs.nl>
   5  * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
   6  * Copyleft (C) 2005 Michel Xhaard mxhaard@magic.fr
   7  *
   8  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  *
  24  */
  25
  26 #define MODULE_NAME "pac207"
  27
  28 #include "gspca.h"
  29
  30 MODULE_AUTHOR("Hans de Goede <j.w.r.degoede@hhs.nl>");
  31 MODULE_DESCRIPTION("Pixart PAC207");
  32 MODULE_LICENSE("GPL");
  33
  34 #define PAC207_CTRL_TIMEOUT             100  /* ms */
  35
  36 #define PAC207_BRIGHTNESS_MIN           0
  37 #define PAC207_BRIGHTNESS_MAX           255
  38 #define PAC207_BRIGHTNESS_DEFAULT       4 /* power on default: 4 */
  39
  40 /* An exposure value of 4 also works (3 does not) but then we need to lower
  41    the compression balance setting when in 352x288 mode, otherwise the usb
  42    bandwidth is not enough and packets get dropped resulting in corrupt
  43    frames. The problem with this is that when the compression balance gets
  44    lowered below 0x80, the pac207 starts using a different compression
  45    algorithm for some lines, these lines get prefixed with a 0x2dd2 prefix
  46    and currently we do not know how to decompress these lines, so for now
  47    we use a minimum exposure value of 5 */
  48 #define PAC207_EXPOSURE_MIN             5
  49 #define PAC207_EXPOSURE_MAX             26
  50 #define PAC207_EXPOSURE_DEFAULT         5 /* power on default: 3 ?? */
  51 #define PAC207_EXPOSURE_KNEE            11 /* 4 = 30 fps, 11 = 8, 15 = 6 */
  52
  53 #define PAC207_GAIN_MIN                 0
  54 #define PAC207_GAIN_MAX                 31
  55 #define PAC207_GAIN_DEFAULT             9 /* power on default: 9 */
  56 #define PAC207_GAIN_KNEE                20
  57
  58 #define PAC207_AUTOGAIN_DEADZONE        30
  59
  60 /* specific webcam descriptor */
  61 struct sd {
  62         struct gspca_dev gspca_dev;             /* !! must be the first item */
  63
  64         u8 mode;
  65
  66         u8 brightness;
  67         u8 exposure;
  68         u8 autogain;
  69         u8 gain;
  70
  71         u8 sof_read;
  72         u8 header_read;
  73         u8 autogain_ignore_frames;
  74
  75         atomic_t avg_lum;
  76 };
  77
  78 /* V4L2 controls supported by the driver */
  79 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
  80 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
  81 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
  82 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
  83 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
  84 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
  85 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
  86 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
  87
  88 static struct ctrl sd_ctrls[] = {
  89 #define SD_BRIGHTNESS 0
  90         {
  91             {
  92                 .id      = V4L2_CID_BRIGHTNESS,
  93                 .type    = V4L2_CTRL_TYPE_INTEGER,
  94                 .name    = "Brightness",
  95                 .minimum = PAC207_BRIGHTNESS_MIN,
  96                 .maximum = PAC207_BRIGHTNESS_MAX,
  97                 .step = 1,
  98                 .default_value = PAC207_BRIGHTNESS_DEFAULT,
  99                 .flags = 0,
 100             },
 101             .set = sd_setbrightness,
 102             .get = sd_getbrightness,
 103         },
 104 #define SD_EXPOSURE 1
 105         {
 106             {
 107                 .id = V4L2_CID_EXPOSURE,
 108                 .type = V4L2_CTRL_TYPE_INTEGER,
 109                 .name = "exposure",
 110                 .minimum = PAC207_EXPOSURE_MIN,
 111                 .maximum = PAC207_EXPOSURE_MAX,
 112                 .step = 1,
 113                 .default_value = PAC207_EXPOSURE_DEFAULT,
 114                 .flags = 0,
 115             },
 116             .set = sd_setexposure,
 117             .get = sd_getexposure,
 118         },
 119 #define SD_AUTOGAIN 2
 120         {
 121             {
 122                 .id       = V4L2_CID_AUTOGAIN,
 123                 .type   = V4L2_CTRL_TYPE_BOOLEAN,
 124                 .name   = "Auto Gain",
 125                 .minimum = 0,
 126                 .maximum = 1,
 127                 .step   = 1,
 128 #define AUTOGAIN_DEF 1
 129                 .default_value = AUTOGAIN_DEF,
 130                 .flags = 0,
 131             },
 132             .set = sd_setautogain,
 133             .get = sd_getautogain,
 134         },
 135 #define SD_GAIN 3
 136         {
 137             {
 138                 .id = V4L2_CID_GAIN,
 139                 .type = V4L2_CTRL_TYPE_INTEGER,
 140                 .name = "gain",
 141                 .minimum = PAC207_GAIN_MIN,
 142                 .maximum = PAC207_GAIN_MAX,
 143                 .step = 1,
 144                 .default_value = PAC207_GAIN_DEFAULT,
 145                 .flags = 0,
 146             },
 147             .set = sd_setgain,
 148             .get = sd_getgain,
 149         },
 150 };
 151
 152 static struct v4l2_pix_format sif_mode[] = {
 153         {176, 144, V4L2_PIX_FMT_PAC207, V4L2_FIELD_NONE,
 154                 .bytesperline = 176,
 155                 .sizeimage = (176 + 2) * 144,
 156                         /* uncompressed, add 2 bytes / line for line header */
 157                 .colorspace = V4L2_COLORSPACE_SRGB,
 158                 .priv = 1},
 159         {352, 288, V4L2_PIX_FMT_PAC207, V4L2_FIELD_NONE,
 160                 .bytesperline = 352,
 161                         /* compressed, but only when needed (not compressed
 162                            when the framerate is low) */
 163                 .sizeimage = (352 + 2) * 288,
 164                 .colorspace = V4L2_COLORSPACE_SRGB,
 165                 .priv = 0},
 166 };
 167
 168 static const __u8 pac207_sensor_init[][8] = {
 169         {0x10, 0x12, 0x0d, 0x12, 0x0c, 0x01, 0x29, 0xf0},
 170         {0x00, 0x64, 0x64, 0x64, 0x04, 0x10, 0xf0, 0x30},
 171         {0x00, 0x00, 0x00, 0x70, 0xa0, 0xf8, 0x00, 0x00},
 172         {0x00, 0x00, 0x32, 0x00, 0x96, 0x00, 0xa2, 0x02},
 173         {0x32, 0x00, 0x96, 0x00, 0xA2, 0x02, 0xaf, 0x00},
 174 };
 175
 176                         /* 48 reg_72 Rate Control end BalSize_4a =0x36 */
 177 static const __u8 PacReg72[] = { 0x00, 0x00, 0x36, 0x00 };
 178
 179 static int pac207_write_regs(struct gspca_dev *gspca_dev, u16 index,
 180         const u8 *buffer, u16 length)
 181 {
 182         struct usb_device *udev = gspca_dev->dev;
 183         int err;
 184
 185         memcpy(gspca_dev->usb_buf, buffer, length);
 186
 187         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x01,
 188                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 189                         0x00, index,
 190                         gspca_dev->usb_buf, length, PAC207_CTRL_TIMEOUT);
 191         if (err < 0)
 192                 PDEBUG(D_ERR,
 193                         "Failed to write registers to index 0x%04X, error %d)",
 194                         index, err);
 195
 196         return err;
 197 }
 198
 199
 200 static int pac207_write_reg(struct gspca_dev *gspca_dev, u16 index, u16 value)
 201 {
 202         struct usb_device *udev = gspca_dev->dev;
 203         int err;
 204
 205         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00,
 206                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 207                         value, index, NULL, 0, PAC207_CTRL_TIMEOUT);
 208         if (err)
 209                 PDEBUG(D_ERR, "Failed to write a register (index 0x%04X,"
 210                         " value 0x%02X, error %d)", index, value, err);
 211
 212         return err;
 213 }
 214
 215 static int pac207_read_reg(struct gspca_dev *gspca_dev, u16 index)
 216 {
 217         struct usb_device *udev = gspca_dev->dev;
 218         int res;
 219
 220         res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
 221                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 222                         0x00, index,
 223                         gspca_dev->usb_buf, 1, PAC207_CTRL_TIMEOUT);
 224         if (res < 0) {
 225                 PDEBUG(D_ERR,
 226                         "Failed to read a register (index 0x%04X, error %d)",
 227                         index, res);
 228                 return res;
 229         }
 230
 231         return gspca_dev->usb_buf[0];
 232 }
 233
 234 /* this function is called at probe time */
 235 static int sd_config(struct gspca_dev *gspca_dev,
 236                         const struct usb_device_id *id)
 237 {
 238         struct sd *sd = (struct sd *) gspca_dev;
 239         struct cam *cam;
 240         u8 idreg[2];
 241
 242         idreg[0] = pac207_read_reg(gspca_dev, 0x0000);
 243         idreg[1] = pac207_read_reg(gspca_dev, 0x0001);
 244         idreg[0] = ((idreg[0] & 0x0F) << 4) | ((idreg[1] & 0xf0) >> 4);
 245         idreg[1] = idreg[1] & 0x0f;
 246         PDEBUG(D_PROBE, "Pixart Sensor ID 0x%02X Chips ID 0x%02X",
 247                 idreg[0], idreg[1]);
 248
 249         if (idreg[0] != 0x27) {
 250                 PDEBUG(D_PROBE, "Error invalid sensor ID!");
 251                 return -ENODEV;
 252         }
 253
 254         PDEBUG(D_PROBE,
 255                 "Pixart PAC207BCA Image Processor and Control Chip detected"
 256                 " (vid/pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
 257
 258         cam = &gspca_dev->cam;
 259         cam->epaddr = 0x05;
 260         cam->cam_mode = sif_mode;
 261         cam->nmodes = ARRAY_SIZE(sif_mode);
 262         sd->brightness = PAC207_BRIGHTNESS_DEFAULT;
 263         sd->exposure = PAC207_EXPOSURE_DEFAULT;
 264         sd->gain = PAC207_GAIN_DEFAULT;
 265         sd->autogain = AUTOGAIN_DEF;
 266
 267         return 0;
 268 }
 269
 270 /* this function is called at probe and resume time */
 271 static int sd_init(struct gspca_dev *gspca_dev)
 272 {
 273         pac207_write_reg(gspca_dev, 0x41, 0x00);
 274                                 /* Bit_0=Image Format,
 275                                  * Bit_1=LED,
 276                                  * Bit_2=Compression test mode enable */
 277         pac207_write_reg(gspca_dev, 0x0f, 0x00); /* Power Control */
 278         pac207_write_reg(gspca_dev, 0x11, 0x30); /* Analog Bias */
 279
 280         return 0;
 281 }
 282
 283 /* -- start the camera -- */
 284 static void sd_start(struct gspca_dev *gspca_dev)
 285 {
 286         struct sd *sd = (struct sd *) gspca_dev;
 287         __u8 mode;
 288
 289         pac207_write_reg(gspca_dev, 0x0f, 0x10); /* Power control (Bit 6-0) */
 290         pac207_write_regs(gspca_dev, 0x0002, pac207_sensor_init[0], 8);
 291         pac207_write_regs(gspca_dev, 0x000a, pac207_sensor_init[1], 8);
 292         pac207_write_regs(gspca_dev, 0x0012, pac207_sensor_init[2], 8);
 293         pac207_write_regs(gspca_dev, 0x0040, pac207_sensor_init[3], 8);
 294         pac207_write_regs(gspca_dev, 0x0042, pac207_sensor_init[4], 8);
 295         pac207_write_regs(gspca_dev, 0x0048, PacReg72, 4);
 296
 297         /* Compression Balance */
 298         if (gspca_dev->width == 176)
 299                 pac207_write_reg(gspca_dev, 0x4a, 0xff);
 300         else
 301                 pac207_write_reg(gspca_dev, 0x4a, 0x88);
 302         pac207_write_reg(gspca_dev, 0x4b, 0x00); /* Sram test value */
 303         pac207_write_reg(gspca_dev, 0x08, sd->brightness);
 304
 305         /* PGA global gain (Bit 4-0) */
 306         pac207_write_reg(gspca_dev, 0x0e, sd->gain);
 307         pac207_write_reg(gspca_dev, 0x02, sd->exposure); /* PXCK = 12MHz /n */
 308
 309         mode = 0x02; /* Image Format (Bit 0), LED (1), Compr. test mode (2) */
 310         if (gspca_dev->width == 176) {  /* 176x144 */
 311                 mode |= 0x01;
 312                 PDEBUG(D_STREAM, "pac207_start mode 176x144");
 313         } else {                                /* 352x288 */
 314                 PDEBUG(D_STREAM, "pac207_start mode 352x288");
 315         }
 316         pac207_write_reg(gspca_dev, 0x41, mode);
 317
 318         pac207_write_reg(gspca_dev, 0x13, 0x01); /* Bit 0, auto clear */
 319         pac207_write_reg(gspca_dev, 0x1c, 0x01); /* not documented */
 320         msleep(10);
 321         pac207_write_reg(gspca_dev, 0x40, 0x01); /* Start ISO pipe */
 322
 323         sd->sof_read = 0;
 324         sd->autogain_ignore_frames = 0;
 325         atomic_set(&sd->avg_lum, -1);
 326 }
 327
 328 static void sd_stopN(struct gspca_dev *gspca_dev)
 329 {
 330         pac207_write_reg(gspca_dev, 0x40, 0x00); /* Stop ISO pipe */
 331         pac207_write_reg(gspca_dev, 0x41, 0x00); /* Turn of LED */
 332         pac207_write_reg(gspca_dev, 0x0f, 0x00); /* Power Control */
 333 }
 334
 335 /* Include pac common sof detection functions */
 336 #include "pac_common.h"
 337
 338 static void pac207_do_auto_gain(struct gspca_dev *gspca_dev)
 339 {
 340         struct sd *sd = (struct sd *) gspca_dev;
 341         int avg_lum = atomic_read(&sd->avg_lum);
 342
 343         if (avg_lum == -1)
 344                 return;
 345
 346         if (sd->autogain_ignore_frames > 0)
 347                 sd->autogain_ignore_frames--;
 348         else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
 349                         100 + sd->brightness / 2, PAC207_AUTOGAIN_DEADZONE,
 350                         PAC207_GAIN_KNEE, PAC207_EXPOSURE_KNEE))
 351                 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
 352 }
 353
 354 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 355                         struct gspca_frame *frame,
 356                         __u8 *data,
 357                         int len)
 358 {
 359         struct sd *sd = (struct sd *) gspca_dev;
 360         unsigned char *sof;
 361
 362         sof = pac_find_sof(gspca_dev, data, len);
 363         if (sof) {
 364                 int n;
 365
 366                 /* finish decoding current frame */
 367                 n = sof - data;
 368                 if (n > sizeof pac_sof_marker)
 369                         n -= sizeof pac_sof_marker;
 370                 else
 371                         n = 0;
 372                 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
 373                                         data, n);
 374                 sd->header_read = 0;
 375                 gspca_frame_add(gspca_dev, FIRST_PACKET, frame, NULL, 0);
 376                 len -= sof - data;
 377                 data = sof;
 378         }
 379         if (sd->header_read < 11) {
 380                 int needed;
 381
 382                 /* get average lumination from frame header (byte 5) */
 383                 if (sd->header_read < 5) {
 384                         needed = 5 - sd->header_read;
 385                         if (len >= needed)
 386                                 atomic_set(&sd->avg_lum, data[needed - 1]);
 387                 }
 388                 /* skip the rest of the header */
 389                 needed = 11 - sd->header_read;
 390                 if (len <= needed) {
 391                         sd->header_read += len;
 392                         return;
 393                 }
 394                 data += needed;
 395                 len -= needed;
 396                 sd->header_read = 11;
 397         }
 398
 399         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
 400 }
 401
 402 static void setbrightness(struct gspca_dev *gspca_dev)
 403 {
 404         struct sd *sd = (struct sd *) gspca_dev;
 405
 406         pac207_write_reg(gspca_dev, 0x08, sd->brightness);
 407         pac207_write_reg(gspca_dev, 0x13, 0x01);        /* Bit 0, auto clear */
 408         pac207_write_reg(gspca_dev, 0x1c, 0x01);        /* not documented */
 409 }
 410
 411 static void setexposure(struct gspca_dev *gspca_dev)
 412 {
 413         struct sd *sd = (struct sd *) gspca_dev;
 414
 415         pac207_write_reg(gspca_dev, 0x02, sd->exposure);
 416         pac207_write_reg(gspca_dev, 0x13, 0x01);        /* Bit 0, auto clear */
 417         pac207_write_reg(gspca_dev, 0x1c, 0x01);        /* not documented */
 418 }
 419
 420 static void setgain(struct gspca_dev *gspca_dev)
 421 {
 422         struct sd *sd = (struct sd *) gspca_dev;
 423
 424         pac207_write_reg(gspca_dev, 0x0e, sd->gain);
 425         pac207_write_reg(gspca_dev, 0x13, 0x01);        /* Bit 0, auto clear */
 426         pac207_write_reg(gspca_dev, 0x1c, 0x01);        /* not documented */
 427 }
 428
 429 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 430 {
 431         struct sd *sd = (struct sd *) gspca_dev;
 432
 433         sd->brightness = val;
 434         if (gspca_dev->streaming)
 435                 setbrightness(gspca_dev);
 436         return 0;
 437 }
 438
 439 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
 440 {
 441         struct sd *sd = (struct sd *) gspca_dev;
 442
 443         *val = sd->brightness;
 444         return 0;
 445 }
 446
 447 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
 448 {
 449         struct sd *sd = (struct sd *) gspca_dev;
 450
 451         sd->exposure = val;
 452         if (gspca_dev->streaming)
 453                 setexposure(gspca_dev);
 454         return 0;
 455 }
 456
 457 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
 458 {
 459         struct sd *sd = (struct sd *) gspca_dev;
 460
 461         *val = sd->exposure;
 462         return 0;
 463 }
 464
 465 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
 466 {
 467         struct sd *sd = (struct sd *) gspca_dev;
 468
 469         sd->gain = val;
 470         if (gspca_dev->streaming)
 471                 setgain(gspca_dev);
 472         return 0;
 473 }
 474
 475 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
 476 {
 477         struct sd *sd = (struct sd *) gspca_dev;
 478
 479         *val = sd->gain;
 480         return 0;
 481 }
 482
 483 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
 484 {
 485         struct sd *sd = (struct sd *) gspca_dev;
 486
 487         sd->autogain = val;
 488         /* when switching to autogain set defaults to make sure
 489            we are on a valid point of the autogain gain /
 490            exposure knee graph, and give this change time to
 491            take effect before doing autogain. */
 492         if (sd->autogain) {
 493                 sd->exposure = PAC207_EXPOSURE_DEFAULT;
 494                 sd->gain = PAC207_GAIN_DEFAULT;
 495                 if (gspca_dev->streaming) {
 496                         sd->autogain_ignore_frames =
 497                                 PAC_AUTOGAIN_IGNORE_FRAMES;
 498                         setexposure(gspca_dev);
 499                         setgain(gspca_dev);
 500                 }
 501         }
 502
 503         return 0;
 504 }
 505
 506 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
 507 {
 508         struct sd *sd = (struct sd *) gspca_dev;
 509
 510         *val = sd->autogain;
 511         return 0;
 512 }
 513
 514 /* sub-driver description */
 515 static const struct sd_desc sd_desc = {
 516         .name = MODULE_NAME,
 517         .ctrls = sd_ctrls,
 518         .nctrls = ARRAY_SIZE(sd_ctrls),
 519         .config = sd_config,
 520         .init = sd_init,
 521         .start = sd_start,
 522         .stopN = sd_stopN,
 523         .dq_callback = pac207_do_auto_gain,
 524         .pkt_scan = sd_pkt_scan,
 525 };
 526
 527 /* -- module initialisation -- */
 528 static const __devinitdata struct usb_device_id device_table[] = {
 529         {USB_DEVICE(0x041e, 0x4028)},
 530         {USB_DEVICE(0x093a, 0x2460)},
 531         {USB_DEVICE(0x093a, 0x2463)},
 532         {USB_DEVICE(0x093a, 0x2464)},
 533         {USB_DEVICE(0x093a, 0x2468)},
 534         {USB_DEVICE(0x093a, 0x2470)},
 535         {USB_DEVICE(0x093a, 0x2471)},
 536         {USB_DEVICE(0x093a, 0x2472)},
 537         {USB_DEVICE(0x093a, 0x2476)},
 538         {USB_DEVICE(0x2001, 0xf115)},
 539         {}
 540 };
 541 MODULE_DEVICE_TABLE(usb, device_table);
 542
 543 /* -- device connect -- */
 544 static int sd_probe(struct usb_interface *intf,
 545                         const struct usb_device_id *id)
 546 {
 547         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 548                                 THIS_MODULE);
 549 }
 550
 551 static struct usb_driver sd_driver = {
 552         .name = MODULE_NAME,
 553         .id_table = device_table,
 554         .probe = sd_probe,
 555         .disconnect = gspca_disconnect,
 556 #ifdef CONFIG_PM
 557         .suspend = gspca_suspend,
 558         .resume = gspca_resume,
 559 #endif
 560 };
 561
 562 /* -- module insert / remove -- */
 563 static int __init sd_mod_init(void)
 564 {
 565         if (usb_register(&sd_driver) < 0)
 566                 return -1;
 567         PDEBUG(D_PROBE, "registered");
 568         return 0;
 569 }
 570 static void __exit sd_mod_exit(void)
 571 {
 572         usb_deregister(&sd_driver);
 573         PDEBUG(D_PROBE, "deregistered");
 574 }
 575
 576 module_init(sd_mod_init);
 577 module_exit(sd_mod_exit);