git.maemo.org Git - kernel-power/blob - usbhost/drivers/usb2/gadget/f_raw.c

   1 /*
   2  * f_raw.c -- USB Raw Access Function Driver
   3  *
   4  * Copyright (C) 2009 Nokia Corporation
   5  * Contact: Felipe Balbi <felipe.balbi@nokia.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21
  22 /* #define VERBOSE_DEBUG */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/utsname.h>
  26 #include <linux/fs.h>
  27 #include <linux/mm.h>
  28 #include <linux/device.h>
  29 #include <linux/wait.h>
  30 #include <linux/list.h>
  31 #include <linux/cdev.h>
  32 #include <linux/poll.h>
  33 #include <linux/dma-mapping.h>
  34 #include <linux/uaccess.h>
  35
  36 #include <linux/usb/ch9.h>
  37 #include <linux/usb/gadget.h>
  38 #include <linux/usb/raw.h>
  39
  40 #include "gadget_chips.h"
  41
  42 struct graw {
  43         struct cdev                     chdev;
  44
  45         struct usb_gadget               *gadget;
  46         struct usb_function             func;
  47
  48         unsigned                        major;
  49         dev_t                           dev;
  50 };
  51
  52 static struct graw *the_graw;
  53 static struct f_raw *the_raw;
  54
  55 struct raw_request {
  56         struct usb_request              *req;
  57         struct list_head                list;
  58         wait_queue_head_t               wait;
  59         unsigned long                   len;
  60
  61         unsigned                        queued:1, completed:1;
  62         int                             nr;
  63 };
  64
  65 struct raw_ep_descs {
  66         struct usb_endpoint_descriptor  *raw_out;
  67 };
  68
  69 struct f_raw {
  70         /* pool of read requests */
  71         struct list_head                read_pool;
  72         int                             nr_reqs;
  73
  74         /* synchronize with userland access */
  75         struct mutex                    mutex;
  76
  77         struct usb_ep                   *out;
  78         struct raw_request              *allocated_req;
  79         struct class                    *class;
  80
  81         struct raw_ep_descs             fs;
  82         struct raw_ep_descs             hs;
  83
  84         struct graw                     graw;
  85
  86         unsigned                        vmas;
  87         unsigned                        connected:1;
  88         unsigned                        can_activate:1;
  89
  90         u8                              intf_id;
  91 };
  92
  93 static inline struct f_raw *func_to_raw(struct usb_function *f)
  94 {
  95         return container_of(f, struct f_raw, graw.func);
  96 }
  97
  98 static u64 raw_dmamask = DMA_BIT_MASK(64);
  99
 100 /*-------------------------------------------------------------------------*/
 101
 102 #define RAW_INTF_IDX    1
 103
 104 static struct usb_string raw_string_defs[] = {
 105         [RAW_INTF_IDX].s        = "Device Upgrade Interface",
 106         {  },   /* end of list */
 107 };
 108
 109 static struct usb_gadget_strings raw_string_table = {
 110         .language               = 0x0409,       /* en-US */
 111         .strings                = raw_string_defs,
 112 };
 113
 114 static struct usb_gadget_strings *raw_strings[] = {
 115         &raw_string_table,
 116         NULL,
 117 };
 118
 119 /*-------------------------------------------------------------------------*/
 120
 121 static struct usb_interface_descriptor raw_intf __initdata = {
 122         .bLength                = sizeof(raw_intf),
 123         .bDescriptorType        = USB_DT_INTERFACE,
 124         .bInterfaceNumber       = 0,
 125
 126         .bAlternateSetting      = 0,
 127         .bNumEndpoints          = 1,
 128         .bInterfaceClass        = USB_CLASS_VENDOR_SPEC,
 129 };
 130
 131 /* High-Speed Support */
 132
 133 static struct usb_endpoint_descriptor raw_hs_ep_out_desc = {
 134         .bLength                = USB_DT_ENDPOINT_SIZE,
 135         .bDescriptorType        = USB_DT_ENDPOINT,
 136
 137         .bEndpointAddress       = USB_DIR_OUT,
 138         .bmAttributes           = USB_ENDPOINT_XFER_BULK,
 139         .wMaxPacketSize         = __constant_cpu_to_le16(512),
 140 };
 141
 142 static struct usb_descriptor_header *hs_function[] __initdata = {
 143         (struct usb_descriptor_header *) &raw_intf,
 144         (struct usb_descriptor_header *) &raw_hs_ep_out_desc,
 145         NULL,
 146 };
 147
 148 /* Full-Speed Support */
 149
 150 static struct usb_endpoint_descriptor raw_fs_ep_out_desc = {
 151         .bLength                = USB_DT_ENDPOINT_SIZE,
 152         .bDescriptorType        = USB_DT_ENDPOINT,
 153
 154         .bEndpointAddress       = USB_DIR_OUT,
 155         .bmAttributes           = USB_ENDPOINT_XFER_BULK,
 156 };
 157
 158 static struct usb_descriptor_header *fs_function[] __initdata = {
 159         (struct usb_descriptor_header *) &raw_intf,
 160         (struct usb_descriptor_header *) &raw_fs_ep_out_desc,
 161         NULL,
 162 };
 163
 164 /*-------------------------------------------------------------------------*/
 165
 166 static void raw_complete(struct usb_ep *ep, struct usb_request *req);
 167
 168 static struct raw_request *raw_alloc_request(struct f_raw *raw, unsigned buflen)
 169 {
 170         struct list_head        *pool = &raw->read_pool;
 171         struct usb_request      *req;
 172         struct raw_request      *raw_req;
 173         void                    *buf;
 174
 175         raw_req = kzalloc(sizeof(*raw_req), GFP_KERNEL);
 176         if (raw_req == NULL)
 177                 goto fail1;
 178
 179         INIT_LIST_HEAD(&raw_req->list);
 180
 181         req = usb_ep_alloc_request(raw->out, GFP_KERNEL);
 182         if (req == NULL)
 183                 goto fail2;
 184
 185         req->length = buflen;
 186         req->complete = raw_complete;
 187         req->context = raw_req;
 188
 189         buf = dma_alloc_coherent(&raw->graw.gadget->dev, buflen,
 190                                  &req->dma, GFP_KERNEL);
 191         if (IS_ERR(buf))
 192                 goto fail3;
 193         req->buf = buf;
 194
 195         raw_req->req = req;
 196         raw_req->len = buflen;
 197
 198         if (raw->nr_reqs == MAX_NR_REQUESTS)
 199                 goto fail4;
 200
 201         raw_req->nr = raw->nr_reqs;
 202         raw->nr_reqs++;
 203         list_add_tail(&raw_req->list, pool);
 204
 205         return raw_req;
 206
 207 fail4:
 208         dma_free_coherent(&raw->graw.gadget->dev, buflen,
 209                           buf, req->dma);
 210
 211 fail3:
 212         usb_ep_free_request(raw->out, req);
 213
 214 fail2:
 215         kfree(raw_req);
 216
 217 fail1:
 218         return NULL;
 219 }
 220
 221 static void raw_complete(struct usb_ep *ep, struct usb_request *req)
 222 {
 223         struct f_raw                    *raw = ep->driver_data;
 224         struct raw_request              *raw_req = req->context;
 225         struct usb_composite_dev        *cdev = raw->graw.func.config->cdev;
 226         int                             status = req->status;
 227
 228         switch (status) {
 229         case 0:                         /* normal completion */
 230                 break;
 231         case -ECONNABORTED:             /* hardware forced ep reset */
 232         case -ECONNRESET:               /* request dequeued */
 233         case -ESHUTDOWN:                /* disconnected from host */
 234                 VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
 235                                 req->actual, req->length);
 236                 return;
 237         case -EOVERFLOW:                /* not big enough buffer */
 238         default:
 239                 DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
 240                                 status, req->actual, req->length);
 241         case -EREMOTEIO:                /* short read */
 242                 break;
 243         }
 244
 245         raw_req->queued = 0;
 246         raw_req->completed = 1;
 247         wake_up_interruptible(&raw_req->wait);
 248 }
 249
 250 static struct raw_request *find_request(struct f_raw *raw, int value)
 251 {
 252         struct raw_request *req;
 253
 254         list_for_each_entry(req, &raw->read_pool, list)
 255                 if (req->nr == value)
 256                         return req;
 257
 258         return NULL;
 259 }
 260
 261 static inline int enable_raw(struct usb_composite_dev *cdev, struct f_raw *raw)
 262 {
 263         const struct usb_endpoint_descriptor    *out_desc;
 264         struct usb_ep                           *ep;
 265
 266         int                                     status = 0;
 267
 268         /* choose endpoint */
 269         out_desc = ep_choose(cdev->gadget, &raw_hs_ep_out_desc,
 270                         &raw_fs_ep_out_desc);
 271
 272         /* enable it */
 273         ep = raw->out;
 274         status = usb_ep_enable(ep, out_desc);
 275         if (status < 0)
 276                 return status;
 277         ep->driver_data = raw;
 278
 279         DBG(cdev, "%s enabled\n", raw->graw.func.name);
 280
 281         return 0;
 282 }
 283
 284 static inline void disable_raw(struct f_raw *raw)
 285 {
 286         struct usb_composite_dev        *cdev;
 287         struct usb_ep                   *ep;
 288
 289         int                             status;
 290
 291         cdev = raw->graw.func.config->cdev;
 292
 293         ep = raw->out;
 294         if (ep->driver_data) {
 295                 status = usb_ep_disable(ep);
 296                 if (status < 0)
 297                         DBG(cdev, "disable %s --> %d\n",
 298                                         ep->name, status);
 299                 ep->driver_data = NULL;
 300         }
 301
 302         VDBG(cdev, "%s disabled\n", raw->graw.func.name);
 303 }
 304
 305 static int raw_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 306 {
 307         struct usb_composite_dev        *cdev = f->config->cdev;
 308         struct f_raw                    *raw = func_to_raw(f);
 309
 310         /* we konw alt is zero */
 311         if (raw->out->driver_data)
 312                 disable_raw(raw);
 313
 314         return enable_raw(cdev, raw);
 315 }
 316
 317 static void raw_disable(struct usb_function *f)
 318 {
 319         struct f_raw    *raw = func_to_raw(f);
 320
 321         disable_raw(raw);
 322 }
 323
 324 static int raw_queue_request(struct f_raw *raw, struct raw_queue_request *qr)
 325 {
 326         struct usb_ep           *ep = raw->out;
 327         struct raw_request      *raw_req;
 328         int                     status = 0;
 329
 330         raw_req = find_request(raw, qr->nr);
 331         if (raw_req == NULL)
 332                 return -ENOENT;
 333
 334         if (qr->nr_bytes > raw_req->len)
 335                 return -EINVAL;
 336
 337         /* FIXME: lock with irqsave and check if transfer already in progress,
 338          * bail out if so. */
 339
 340         raw_req->req->length = qr->nr_bytes;
 341
 342         init_waitqueue_head(&raw_req->wait);
 343         raw_req->completed = 0;
 344         raw_req->queued = 1;
 345         status = usb_ep_queue(ep, raw_req->req, GFP_KERNEL);
 346         if (status) {
 347                 struct usb_composite_dev        *cdev;
 348
 349                 cdev = raw->graw.func.config->cdev;
 350                 ERROR(cdev, "start %s %s --> %d\n", "OUT", ep->name, status);
 351                 raw_req->queued = 0;
 352         }
 353
 354         return status;
 355 }
 356
 357 static int raw_free_request(struct f_raw *raw, int nr)
 358 {
 359         struct raw_request *raw_req;
 360         struct usb_request *req;
 361
 362         raw_req = find_request(raw, nr);
 363         if (raw_req == NULL)
 364                 return -ENOENT;
 365
 366         if (raw->allocated_req == raw_req)
 367                 raw->allocated_req = NULL;
 368         /* FIXME: munmap? */
 369
 370         req = raw_req->req;
 371         /* FIXME: spinlocking? */
 372         if (raw_req->queued)
 373                 usb_ep_dequeue(raw->out, req);
 374         raw_req->queued = 0;
 375         dma_free_coherent(&raw->graw.gadget->dev, raw_req->len, req->buf,
 376                         req->dma);
 377         usb_ep_free_request(raw->out, req);
 378         list_del(&raw_req->list);
 379         kfree(raw_req);
 380
 381         return 0;
 382 }
 383
 384 static int raw_get_request_status(struct f_raw *raw,
 385                                   struct raw_request_status *st)
 386 {
 387         struct raw_request      *raw_req;
 388
 389         raw_req = find_request(raw, st->nr);
 390         if (raw_req == NULL)
 391                 return -ENOENT;
 392
 393         if (!raw_req->queued) {
 394                 st->status = raw_req->req->status;
 395                 st->nr_bytes = raw_req->req->actual;
 396                 raw_req->completed = 0;
 397         } else {
 398                 st->status = -EBUSY;
 399                 st->nr_bytes = 0;
 400         }
 401
 402         return 0;
 403 }
 404
 405 static void get_completion_map(struct f_raw *raw, unsigned int *mask_out)
 406 {
 407         struct raw_request *req;
 408         unsigned int mask = 0;
 409
 410         list_for_each_entry(req, &raw->read_pool, list)
 411                 if (req->completed)
 412                         mask |= (1 << req->nr);
 413
 414         *mask_out = mask;
 415 }
 416
 417 static long fraw_ioctl(struct file *filp, unsigned code, unsigned long value)
 418 {
 419         struct f_raw                    *raw = filp->private_data;
 420         struct usb_ep                   *ep = raw->out;
 421         unsigned int                    map;
 422         int                             status = 0;
 423         struct raw_request_status       req_st;
 424         struct raw_queue_request        que_req;
 425
 426         if (unlikely(!ep))
 427                 return -EINVAL;
 428
 429         mutex_lock(&raw->mutex);
 430
 431         switch (code) {
 432         case RAW_FIFO_STATUS:
 433                 status = usb_ep_fifo_status(ep);
 434                 break;
 435         case RAW_FIFO_FLUSH:
 436                 usb_ep_fifo_flush(ep);
 437                 break;
 438         case RAW_CLEAR_HALT:
 439                 status = usb_ep_clear_halt(ep);
 440                 break;
 441         case RAW_ALLOC_REQUEST:
 442                 if (raw->allocated_req != NULL) {
 443                         status = -EBUSY;
 444                         break;
 445                 }
 446                 if (value > MAX_REQUEST_LEN || (value % PAGE_SIZE) != 0) {
 447                         status = -EINVAL;
 448                         break;
 449                 }
 450                 raw->allocated_req = raw_alloc_request(raw, value);
 451                 if (raw->allocated_req == NULL) {
 452                         status = -ENOMEM;
 453                         break;
 454                 }
 455                 status = raw->allocated_req->nr;
 456                 break;
 457         case RAW_QUEUE_REQUEST:
 458                 status = copy_from_user(&que_req, (void __user *) value,
 459                                         sizeof(que_req));
 460                 if (status)
 461                         break;
 462                 status = raw_queue_request(raw, &que_req);
 463                 break;
 464         case RAW_FREE_REQUEST:
 465                 status = raw_free_request(raw, value);
 466                 break;
 467         case RAW_GET_COMPLETION_MAP:
 468                 get_completion_map(raw, &map);
 469                 status = put_user(map, (unsigned int __user *) value);
 470                 break;
 471         case RAW_GET_REQUEST_STATUS:
 472                 status = copy_from_user(&req_st, (void __user *) value,
 473                                         sizeof(req_st));
 474                 if (status)
 475                         break;
 476                 status = raw_get_request_status(raw, &req_st);
 477                 if (status)
 478                         break;
 479                 status = copy_to_user((void __user *) value, &req_st,
 480                                       sizeof(req_st));
 481         }
 482
 483         mutex_unlock(&raw->mutex);
 484
 485         return status;
 486 }
 487
 488 static int fraw_mmap(struct file *filp, struct vm_area_struct *vma)
 489 {
 490         size_t                  size = vma->vm_end - vma->vm_start;
 491         struct f_raw            *raw = filp->private_data;
 492         struct raw_request      *raw_req;
 493         struct usb_request      *req;
 494         int                     ret;
 495
 496         mutex_lock(&raw->mutex);
 497         raw_req = raw->allocated_req;
 498         if (raw_req == NULL) {
 499                 ret = -ENXIO;
 500                 goto out;
 501         }
 502         req = raw_req->req;
 503
 504         if (size != raw_req->len) {
 505                 ret = -EINVAL;
 506                 goto out;
 507         }
 508
 509         vma->vm_private_data = raw;
 510
 511         ret = dma_mmap_coherent(&raw->graw.gadget->dev, vma, req->buf,
 512                                 req->dma, raw_req->len);
 513         if (ret < 0)
 514                 goto out;
 515
 516         raw->allocated_req = NULL;
 517
 518 out:
 519         mutex_unlock(&raw->mutex);
 520
 521         return 0;
 522 }
 523
 524 static int fraw_open(struct inode *inode, struct file *filp)
 525 {
 526         struct f_raw                    *raw;
 527
 528         raw = the_raw;
 529         filp->private_data = the_raw;
 530
 531         return 0;
 532 }
 533
 534 static int fraw_release(struct inode *inode, struct file *filp)
 535 {
 536         struct f_raw                    *raw = filp->private_data;
 537
 538         while (!list_empty(&raw->read_pool)) {
 539                 struct raw_request *req;
 540
 541                 req = list_first_entry(&raw->read_pool, struct raw_request,
 542                                        list);
 543                 raw_free_request(raw, req->nr);
 544         }
 545         raw->nr_reqs = 0;
 546         filp->private_data = NULL;
 547
 548         return 0;
 549 }
 550
 551 static unsigned int fraw_poll(struct file *filp, struct poll_table_struct *pt)
 552 {
 553         struct f_raw                    *raw = filp->private_data;
 554         struct raw_request              *req;
 555         int                             ret = 0;
 556
 557         mutex_lock(&raw->mutex);
 558         list_for_each_entry(req, &raw->read_pool, list) {
 559                 poll_wait(filp, &req->wait, pt);
 560
 561                 if (req->completed) {
 562                         ret = POLLIN | POLLRDNORM;
 563                         break;
 564                 }
 565         }
 566         mutex_unlock(&raw->mutex);
 567
 568         return ret;
 569 }
 570
 571 static struct file_operations fraw_fops = {
 572         .owner          = THIS_MODULE,
 573         .open           = fraw_open,
 574         .release        = fraw_release,
 575         .unlocked_ioctl = fraw_ioctl,
 576         .mmap           = fraw_mmap,
 577         .poll           = fraw_poll,
 578 };
 579
 580 /*-------------------------------------------------------------------------*/
 581
 582 static int __init raw_bind(struct usb_configuration *c, struct usb_function *f)
 583 {
 584         struct usb_composite_dev        *cdev = c->cdev;
 585         struct f_raw                    *raw = func_to_raw(f);
 586         struct usb_ep                   *ep;
 587
 588         int                             status;
 589
 590         /* allocate instance-specific interface IDs and patch descriptors */
 591
 592         status = usb_interface_id(c, f);
 593         if (status < 0)
 594                 goto fail;
 595         raw->intf_id = status;
 596
 597         raw_intf.bInterfaceNumber = status;
 598
 599         /* allocate instance-specific endpoints */
 600
 601         ep = usb_ep_autoconfig(cdev->gadget, &raw_fs_ep_out_desc);
 602         if (!ep)
 603                 goto fail;
 604         raw->out = ep;
 605         ep->driver_data = cdev; /* claim */
 606
 607         /* copy descriptors and track endpoint copies */
 608         f->descriptors = usb_copy_descriptors(fs_function);
 609
 610         raw->fs.raw_out = usb_find_endpoint(fs_function,
 611                         f->descriptors, &raw_fs_ep_out_desc);
 612
 613         /* support all relevant hardware speeds... we expect that when
 614          * hardware is dual speed, all bulk-capable endpoints work at
 615          * both speeds
 616          */
 617         if (gadget_is_dualspeed(c->cdev->gadget)) {
 618                 raw_hs_ep_out_desc.bEndpointAddress =
 619                         raw_fs_ep_out_desc.bEndpointAddress;
 620
 621                 /* copy descriptors and track endpoint copies */
 622                 f->hs_descriptors = usb_copy_descriptors(hs_function);
 623
 624                 raw->hs.raw_out = usb_find_endpoint(hs_function,
 625                                 f->hs_descriptors, &raw_hs_ep_out_desc);
 626         }
 627
 628         INIT_LIST_HEAD(&raw->read_pool);
 629         mutex_init(&raw->mutex);
 630
 631         /* create device nodes */
 632         raw->class = class_create(THIS_MODULE, "fraw");
 633         device_create(raw->class, &cdev->gadget->dev,
 634                         MKDEV(raw->graw.major, 0), raw, "%s", f->name);
 635
 636         cdev->gadget->dev.dma_mask = &raw_dmamask;
 637         cdev->gadget->dev.coherent_dma_mask = DMA_64BIT_MASK;
 638         raw->graw.gadget = cdev->gadget;
 639         the_raw = raw;
 640
 641         DBG(cdev, "raw: %s speed OUT/%s\n",
 642                         gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
 643                         raw->out->name);
 644
 645         return 0;
 646
 647 fail:
 648         if (raw->class)
 649                 class_destroy(raw->class);
 650
 651         if (raw->out)
 652                 raw->out->driver_data = NULL;
 653
 654         ERROR(cdev, "%s/%p: can't bind, err %d\n", f->name, f, status);
 655
 656         return status;
 657 }
 658
 659 static void raw_unbind(struct usb_configuration *c, struct usb_function *f)
 660 {
 661         struct f_raw *raw = func_to_raw(f);
 662
 663         if (gadget_is_dualspeed(c->cdev->gadget))
 664                 usb_free_descriptors(f->hs_descriptors);
 665         usb_free_descriptors(f->descriptors);
 666         device_destroy(raw->class, MKDEV(raw->graw.major, 0));
 667         class_destroy(raw->class);
 668         kfree(raw);
 669 }
 670
 671 /**
 672  * raw_bind_config - add a RAW function to a configuration
 673  * @c: the configuration to support the RAW instance
 674  * Context: single threaded during gadget setup
 675  *
 676  * Returns zero on success, else negative errno.
 677  */
 678 static int __init raw_bind_config(struct usb_configuration *c)
 679 {
 680         struct f_raw    *raw;
 681         int             status;
 682
 683         if (raw_string_defs[RAW_INTF_IDX].id == 0) {
 684                 status = usb_string_id(c->cdev);
 685                 if (status < 0)
 686                         return status;
 687
 688                 raw_string_defs[RAW_INTF_IDX].id = status;
 689                 raw_intf.iInterface = status;
 690         }
 691
 692         /* allocate and initialize one new instance */
 693         raw = kzalloc(sizeof(*raw), GFP_KERNEL);
 694         if (!raw)
 695                 return -ENOMEM;
 696
 697         raw->graw.func.name     = "raw";
 698         raw->graw.func.strings  = raw_strings;
 699         /* descriptors are per-instance copies */
 700         raw->graw.func.bind     = raw_bind;
 701         raw->graw.func.unbind   = raw_unbind;
 702         raw->graw.func.set_alt  = raw_set_alt;
 703         raw->graw.func.disable  = raw_disable;
 704
 705         status = usb_add_function(c, &raw->graw.func);
 706         if (status)
 707                 kfree(raw);
 708
 709         return status;
 710 }
 711
 712 /**
 713  * graw_setup - initialize character driver for one rx
 714  * @g: gadget to associate with
 715  * Contex: may sleep
 716  *
 717  * Returns negative errno or zero.
 718  */
 719 static int __init graw_setup(struct usb_gadget *g)
 720 {
 721         struct graw     *graw;
 722
 723         int             status;
 724         int             major;
 725
 726         dev_t           dev;
 727
 728         if (the_graw)
 729                 return -EBUSY;
 730
 731         graw = kzalloc(sizeof(*graw), GFP_KERNEL);
 732         if (!graw) {
 733                 status = -ENOMEM;
 734                 goto fail1;
 735         }
 736
 737         status = alloc_chrdev_region(&dev, 0, 1, "fraw");
 738         if (status)
 739                 goto fail2;
 740
 741         major = MAJOR(dev);
 742
 743         cdev_init(&graw->chdev, &fraw_fops);
 744         graw->chdev.owner       = THIS_MODULE;
 745         graw->dev               = dev;
 746         graw->major             = major;
 747
 748         status = cdev_add(&graw->chdev, dev, 1);
 749         if (status)
 750                 goto fail3;
 751
 752         the_graw = graw;
 753
 754         return 0;
 755
 756 fail3:
 757         /* cdev_put(&graw->cdev); */
 758         unregister_chrdev_region(graw->dev, 1);
 759
 760 fail2:
 761         kfree(graw);
 762
 763 fail1:
 764         return status;
 765 }
 766
 767 static void __exit graw_cleanup(void)
 768 {
 769         struct graw     *graw = the_graw;
 770
 771         if (!graw)
 772                 return;
 773
 774         cdev_del(&graw->chdev);
 775         /* cdev_put(&graw->chdev); */
 776         unregister_chrdev_region(graw->dev, 1);
 777         kfree(graw);
 778 }
 779