usr/src/uts/common/io/usb/usba10/usba10.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26
  27 /*
  28  * Dummy module to load usba module on behalf of legacy drivers.
  29  *
  30  * Please see the on81-patch gate include/sys/usba10/usba10_usbai.h
  31  * header file for descriptions and comments for these functions.
  32  */
  33
  34 #include <sys/usb/usba.h>
  35 #include <sys/usb/usba/usbai_private.h>
  36 #include <sys/usb/usba/usba10.h>
  37
  38 /*
  39  * modload support
  40  */
  41
  42 static struct modlmisc modlmisc = {
  43         &mod_miscops,   /* Type of module */
  44         "USBA10: USB V0.8 Drvr Supp"
  45 };
  46
  47 static struct modlinkage modlinkage = {
  48         MODREV_1, (void *)&modlmisc, NULL
  49 };
  50
  51
  52 int
  53 _init(void)
  54 {
  55         return (mod_install(&modlinkage));
  56 }
  57
  58 int
  59 _fini()
  60 {
  61         return (mod_remove(&modlinkage));
  62 }
  63
  64 int
  65 _info(struct modinfo *modinfop)
  66 {
  67         return (mod_info(&modlinkage, modinfop));
  68 }
  69
  70 /*
  71  * Turn off lint checking of this module because it will find duplicate names
  72  * defined here and in the usbai.c source for the usba module.
  73  */
  74
  75 int
  76 usb_register_client(
  77         dev_info_t                      *dip,
  78         uint_t                          version,
  79         usb_client_dev_data_t           **dev_data,
  80         usb_reg_parse_lvl_t             parse_level,
  81         usb_flags_t                     flags)
  82 {
  83         return (usba10_usb_register_client(
  84             dip, version, dev_data, parse_level, flags));
  85 }
  86
  87
  88 void
  89 usb_unregister_client(
  90         dev_info_t                      *dip,
  91         usb_client_dev_data_t           *dev_data)
  92 {
  93         usba10_usb_unregister_client(dip, dev_data);
  94 }
  95
  96
  97 void
  98 usb_free_descr_tree(
  99         dev_info_t                      *dip,
 100         usb_client_dev_data_t           *dev_data)
 101 {
 102         usba10_usb_free_descr_tree(dip, dev_data);
 103 }
 104
 105
 106 size_t
 107 usb_parse_data(
 108         char                    *format,
 109         uchar_t                 *data,
 110         size_t                  datalen,
 111         void                    *structure,
 112         size_t                  structlen)
 113 {
 114         return (usba10_usb_parse_data(
 115             format, data, datalen, structure, structlen));
 116 }
 117
 118
 119 usb_ep_data_t *
 120 usb_get_ep_data(
 121         dev_info_t              *dip,
 122         usb_client_dev_data_t   *dev_datap,
 123         uint_t                  interface,
 124         uint_t                  alternate,
 125         uint_t                  type,
 126         uint_t                  direction)
 127 {
 128         return (usba10_usb_get_ep_data(
 129             dip, dev_datap, interface, alternate, type, direction));
 130 }
 131
 132
 133 int
 134 usb_get_string_descr(
 135         dev_info_t              *dip,
 136         uint16_t                langid,
 137         uint8_t                 index,
 138         char                    *buf,
 139         size_t                  buflen)
 140 {
 141         return (usba10_usb_get_string_descr(dip, langid, index, buf, buflen));
 142 }
 143
 144
 145 int
 146 usb_get_addr(dev_info_t *dip)
 147 {
 148         return (usba10_usb_get_addr(dip));
 149 }
 150
 151
 152 int
 153 usb_get_if_number(dev_info_t *dip)
 154 {
 155         return (usba10_usb_get_if_number(dip));
 156 }
 157
 158
 159 boolean_t
 160 usb_owns_device(dev_info_t *dip)
 161 {
 162         return (usba10_usb_owns_device(dip));
 163 }
 164
 165
 166 int
 167 usb_pipe_get_state(
 168         usb_pipe_handle_t       pipe_handle,
 169         usb_pipe_state_t        *pipe_state,
 170         usb_flags_t             flags)
 171 {
 172         return (usba10_usb_pipe_get_state(pipe_handle, pipe_state, flags));
 173 }
 174
 175
 176 int
 177 usb_ep_num(usb_pipe_handle_t ph)
 178 {
 179         return (usba10_usb_ep_num(ph));
 180 }
 181
 182
 183 int
 184 usb_pipe_open(
 185         dev_info_t              *dip,
 186         usb_ep_descr_t          *ep,
 187         usb_pipe_policy_t       *pipe_policy,
 188         usb_flags_t             flags,
 189         usb_pipe_handle_t       *pipe_handle)
 190 {
 191         return (usba10_usb_pipe_open(dip, ep, pipe_policy, flags, pipe_handle));
 192 }
 193
 194
 195 void
 196 usb_pipe_close(
 197         dev_info_t              *dip,
 198         usb_pipe_handle_t       pipe_handle,
 199         usb_flags_t             flags,
 200         void                    (*cb)(
 201                                     usb_pipe_handle_t   ph,
 202                                     usb_opaque_t        arg,    /* cb arg */
 203                                     int                 rval,
 204                                     usb_cb_flags_t      flags),
 205         usb_opaque_t            cb_arg)
 206 {
 207         usba10_usb_pipe_close(dip, pipe_handle, flags, cb, cb_arg);
 208 }
 209
 210
 211 int
 212 usb_pipe_drain_reqs(
 213         dev_info_t              *dip,
 214         usb_pipe_handle_t       pipe_handle,
 215         uint_t                  time,
 216         usb_flags_t             flags,
 217         void                    (*cb)(
 218                                     usb_pipe_handle_t   ph,
 219                                     usb_opaque_t        arg,    /* cb arg */
 220                                     int                 rval,
 221                                     usb_cb_flags_t      flags),
 222         usb_opaque_t            cb_arg)
 223 {
 224         return (usba10_usb_pipe_drain_reqs(
 225             dip, pipe_handle, time, flags, cb, cb_arg));
 226 }
 227
 228
 229 int
 230 usb_pipe_set_private(
 231         usb_pipe_handle_t       pipe_handle,
 232         usb_opaque_t            data)
 233 {
 234         return (usba10_usb_pipe_set_private(pipe_handle, data));
 235 }
 236
 237
 238 usb_opaque_t
 239 usb_pipe_get_private(usb_pipe_handle_t pipe_handle)
 240 {
 241         return (usba10_usb_pipe_get_private(pipe_handle));
 242 }
 243
 244
 245 void
 246 usb_pipe_reset(
 247         dev_info_t              *dip,
 248         usb_pipe_handle_t       pipe_handle,
 249         usb_flags_t             usb_flags,
 250         void                    (*cb)(
 251                                         usb_pipe_handle_t ph,
 252                                         usb_opaque_t    arg,
 253                                         int             rval,
 254                                         usb_cb_flags_t  flags),
 255         usb_opaque_t            cb_arg)
 256 {
 257         usba10_usb_pipe_reset(dip, pipe_handle, usb_flags, cb, cb_arg);
 258 }
 259
 260
 261 usb_ctrl_req_t *
 262 usb_alloc_ctrl_req(
 263         dev_info_t              *dip,
 264         size_t                  len,
 265         usb_flags_t             flags)
 266 {
 267         return (usba10_usb_alloc_ctrl_req(dip, len, flags));
 268 }
 269
 270
 271 void
 272 usb_free_ctrl_req(usb_ctrl_req_t *reqp)
 273 {
 274         usba10_usb_free_ctrl_req(reqp);
 275 }
 276
 277
 278 int
 279 usb_pipe_ctrl_xfer(
 280         usb_pipe_handle_t       pipe_handle,
 281         usb_ctrl_req_t          *reqp,
 282         usb_flags_t             flags)
 283 {
 284         return (usba10_usb_pipe_ctrl_xfer(pipe_handle, reqp, flags));
 285 }
 286
 287
 288 int
 289 usb_get_status(
 290         dev_info_t              *dip,
 291         usb_pipe_handle_t       ph,
 292         uint_t                  type,   /* bmRequestType */
 293         uint_t                  what,   /* 0, interface, endpoint number */
 294         uint16_t                *status,
 295         usb_flags_t             flags)
 296 {
 297         return (usba10_usb_get_status(dip, ph, type, what, status, flags));
 298 }
 299
 300
 301 int
 302 usb_clear_feature(
 303         dev_info_t              *dip,
 304         usb_pipe_handle_t       ph,
 305         uint_t                  type,   /* bmRequestType */
 306         uint_t                  feature,
 307         uint_t                  what,   /* 0, interface, endpoint number */
 308         usb_flags_t             flags)
 309 {
 310         return (usba10_usb_clear_feature(dip, ph, type, feature, what, flags));
 311 }
 312
 313
 314 int
 315 usb_pipe_ctrl_xfer_wait(
 316         usb_pipe_handle_t       pipe_handle,
 317         usb_ctrl_setup_t        *setup,
 318         mblk_t                  **data,
 319         usb_cr_t                *completion_reason,
 320         usb_cb_flags_t          *cb_flags,
 321         usb_flags_t             flags)
 322 {
 323         return (usba10_usb_pipe_ctrl_xfer_wait(
 324             pipe_handle, setup, data, completion_reason, cb_flags, flags));
 325 }
 326
 327
 328 int
 329 usb_set_cfg(
 330         dev_info_t              *dip,
 331         uint_t                  cfg_index,
 332         usb_flags_t             usb_flags,
 333         void                    (*cb)(
 334                                         usb_pipe_handle_t ph,
 335                                         usb_opaque_t    arg,
 336                                         int             rval,
 337                                         usb_cb_flags_t  flags),
 338         usb_opaque_t            cb_arg)
 339 {
 340         return (usba10_usb_set_cfg(dip, cfg_index, usb_flags, cb, cb_arg));
 341 }
 342
 343
 344 int
 345 usb_get_cfg(
 346         dev_info_t              *dip,
 347         uint_t                  *cfgval,
 348         usb_flags_t             usb_flags)
 349 {
 350         return (usba10_usb_get_cfg(dip, cfgval, usb_flags));
 351 }
 352
 353
 354 int
 355 usb_set_alt_if(
 356         dev_info_t              *dip,
 357         uint_t                  interface,
 358         uint_t                  alt_number,
 359         usb_flags_t             usb_flags,
 360         void                    (*cb)(
 361                                         usb_pipe_handle_t ph,
 362                                         usb_opaque_t    arg,
 363                                         int             rval,
 364                                         usb_cb_flags_t  flags),
 365         usb_opaque_t            cb_arg)
 366 {
 367         return (usba10_usb_set_alt_if(
 368             dip, interface, alt_number, usb_flags, cb, cb_arg));
 369 }
 370
 371
 372 int
 373 usb_get_alt_if(
 374         dev_info_t              *dip,
 375         uint_t                  if_number,
 376         uint_t                  *alt_number,
 377         usb_flags_t             flags)
 378 {
 379         return (usba10_usb_get_alt_if(dip, if_number, alt_number, flags));
 380 }
 381
 382
 383 usb_bulk_req_t *
 384 usb_alloc_bulk_req(
 385         dev_info_t              *dip,
 386         size_t                  len,
 387         usb_flags_t             flags)
 388 {
 389         return (usba10_usb_alloc_bulk_req(dip, len, flags));
 390 }
 391
 392
 393 void
 394 usb_free_bulk_req(usb_bulk_req_t *reqp)
 395 {
 396         usba10_usb_free_bulk_req(reqp);
 397 }
 398
 399
 400 int
 401 usb_pipe_bulk_xfer(
 402         usb_pipe_handle_t       pipe_handle,
 403         usb_bulk_req_t          *reqp,
 404         usb_flags_t             flags)
 405 {
 406         return (usba10_usb_pipe_bulk_xfer(pipe_handle, reqp, flags));
 407 }
 408
 409
 410 int
 411 usb_pipe_bulk_transfer_size(
 412         dev_info_t              *dip,
 413         size_t                  *size)
 414 {
 415         return (usba10_usb_pipe_bulk_transfer_size(dip, size));
 416 }
 417
 418
 419 usb_intr_req_t *
 420 usb_alloc_intr_req(
 421         dev_info_t              *dip,
 422         size_t                  len,
 423         usb_flags_t             flags)
 424 {
 425         return (usba10_usb_alloc_intr_req(dip, len, flags));
 426 }
 427
 428
 429 void
 430 usb_free_intr_req(usb_intr_req_t *reqp)
 431 {
 432         usba10_usb_free_intr_req(reqp);
 433 }
 434
 435
 436 int
 437 usb_pipe_intr_xfer(
 438         usb_pipe_handle_t       pipe_handle,
 439         usb_intr_req_t          *req,
 440         usb_flags_t             flags)
 441 {
 442         return (usba10_usb_pipe_intr_xfer(pipe_handle, req, flags));
 443 }
 444
 445
 446 void
 447 usb_pipe_stop_intr_polling(
 448         usb_pipe_handle_t       pipe_handle,
 449         usb_flags_t             flags)
 450 {
 451         usba10_usb_pipe_stop_intr_polling(pipe_handle, flags);
 452 }
 453
 454
 455 usb_isoc_req_t *
 456 usb_alloc_isoc_req(
 457         dev_info_t              *dip,
 458         uint_t                  isoc_pkts_count,
 459         size_t                  len,
 460         usb_flags_t             flags)
 461 {
 462         return (usba10_usb_alloc_isoc_req(dip, isoc_pkts_count, len, flags));
 463 }
 464
 465
 466 void
 467 usb_free_isoc_req(usb_isoc_req_t *usb_isoc_req)
 468 {
 469         usba10_usb_free_isoc_req(usb_isoc_req);
 470 }
 471
 472
 473 usb_frame_number_t
 474 usb_get_current_frame_number(dev_info_t *dip)
 475 {
 476         return (usba10_usb_get_current_frame_number(dip));
 477 }
 478
 479
 480 uint_t
 481 usb_get_max_isoc_pkts(dev_info_t *dip)
 482 {
 483         return (usba10_usb_get_max_isoc_pkts(dip));
 484 }
 485
 486
 487 int
 488 usb_pipe_isoc_xfer(
 489         usb_pipe_handle_t       pipe_handle,
 490         usb_isoc_req_t          *reqp,
 491         usb_flags_t             flags)
 492 {
 493         return (usba10_usb_pipe_isoc_xfer(pipe_handle, reqp, flags));
 494 }
 495
 496
 497 void
 498 usb_pipe_stop_isoc_polling(
 499         usb_pipe_handle_t       pipe_handle,
 500         usb_flags_t             flags)
 501 {
 502         usba10_usb_pipe_stop_isoc_polling(pipe_handle, flags);
 503 }
 504
 505
 506 int
 507 usb_req_raise_power(
 508         dev_info_t      *dip,
 509         int             comp,
 510         int             level,
 511         void            (*cb)(void *arg, int rval),
 512         void            *arg,
 513         usb_flags_t     flags)
 514 {
 515         return (usba10_usb_req_raise_power(dip, comp, level, cb, arg, flags));
 516 }
 517
 518
 519 int
 520 usb_req_lower_power(
 521         dev_info_t      *dip,
 522         int             comp,
 523         int             level,
 524         void            (*cb)(void *arg, int rval),
 525         void            *arg,
 526         usb_flags_t     flags)
 527 {
 528         return (usba10_usb_req_raise_power(dip, comp, level, cb, arg, flags));
 529 }
 530
 531
 532 int
 533 usb_is_pm_enabled(dev_info_t *dip)
 534 {
 535         return (usba10_usb_is_pm_enabled(dip));
 536 }
 537
 538 int
 539 usb_handle_remote_wakeup(
 540         dev_info_t      *dip,
 541         int             cmd)
 542 {
 543         return (usba10_usb_handle_remote_wakeup(dip, cmd));
 544 }
 545
 546
 547 int
 548 usb_create_pm_components(
 549         dev_info_t      *dip,
 550         uint_t          *pwrstates)
 551 {
 552         return (usba10_usb_create_pm_components(dip, pwrstates));
 553 }
 554
 555
 556 int
 557 usb_set_device_pwrlvl0(dev_info_t *dip)
 558 {
 559         return (usba10_usb_set_device_pwrlvl0(dip));
 560 }
 561
 562
 563 int
 564 usb_set_device_pwrlvl1(dev_info_t *dip)
 565 {
 566         return (usba10_usb_set_device_pwrlvl1(dip));
 567 }
 568
 569
 570 int
 571 usb_set_device_pwrlvl2(dev_info_t *dip)
 572 {
 573         return (usba10_usb_set_device_pwrlvl2(dip));
 574 }
 575
 576
 577 int
 578 usb_set_device_pwrlvl3(dev_info_t *dip)
 579 {
 580         return (usba10_usb_set_device_pwrlvl3(dip));
 581 }
 582
 583
 584 int
 585 usb_async_req(
 586         dev_info_t      *dip,
 587         void            (*func)(void *),
 588         void            *arg,
 589         usb_flags_t     flag)
 590 {
 591         return (usba10_usb_async_req(dip, func, arg, flag));
 592 }
 593
 594
 595 int
 596 usb_register_event_cbs(
 597         dev_info_t      *dip,
 598         usb_event_t     *usb_evt_data,
 599         usb_flags_t     flags)
 600 {
 601         return (usba10_usb_register_event_cbs(dip, usb_evt_data, flags));
 602 }
 603
 604
 605 void
 606 usb_unregister_event_cbs(
 607         dev_info_t      *dip,
 608         usb_event_t     *usb_evt_data)
 609 {
 610         usba10_usb_unregister_event_cbs(dip, usb_evt_data);
 611 }
 612
 613
 614 void
 615 usb_fail_checkpoint(
 616         dev_info_t      *dip,
 617         usb_flags_t     flags)
 618 {
 619         usba10_usb_fail_checkpoint(dip, flags);
 620 }
 621
 622 #ifdef DEBUG
 623
 624 void usb_dprintf4(
 625         uint_t          mask,
 626         usb_log_handle_t handle,
 627         char            *fmt, ...)
 628 {
 629         va_list ap;
 630
 631         va_start(ap, fmt);
 632         (void) usba10_usba_vlog(handle, USB_LOG_L4, mask, fmt, ap);
 633         va_end(ap);
 634 }
 635
 636
 637 void usb_dprintf3(
 638         uint_t          mask,
 639         usb_log_handle_t handle,
 640         char            *fmt, ...)
 641 {
 642         va_list ap;
 643
 644         va_start(ap, fmt);
 645         (void) usba10_usba_vlog(handle, USB_LOG_L3, mask, fmt, ap);
 646         va_end(ap);
 647 }
 648
 649
 650 void usb_dprintf2(
 651         uint_t          mask,
 652         usb_log_handle_t handle,
 653         char            *fmt, ...)
 654 {
 655         va_list ap;
 656
 657         va_start(ap, fmt);
 658         (void) usba10_usba_vlog(handle, USB_LOG_L2, mask, fmt, ap);
 659         va_end(ap);
 660 }
 661
 662 #endif
 663
 664 void usb_dprintf1(
 665         uint_t          mask,
 666         usb_log_handle_t handle,
 667         char            *fmt, ...)
 668 {
 669         va_list ap;
 670
 671         va_start(ap, fmt);
 672         (void) usba10_usba_vlog(handle, USB_LOG_L1, mask, fmt, ap);
 673         va_end(ap);
 674 }
 675
 676
 677
 678 void usb_dprintf0(
 679         uint_t          mask,
 680         usb_log_handle_t handle,
 681         char            *fmt, ...)
 682 {
 683         va_list ap;
 684
 685         va_start(ap, fmt);
 686         (void) usba10_usba_vlog(handle, USB_LOG_L4, mask, fmt, ap);
 687         va_end(ap);
 688 }
 689
 690 usb_log_handle_t
 691 usb_alloc_log_handle(
 692         dev_info_t      *dip,
 693         char            *name,
 694         uint_t          *errlevel,
 695         uint_t          *mask,
 696         uint_t          *instance_filter,
 697         uint_t          show_label,
 698         usb_flags_t     flags)
 699 {
 700         return (usba10_usb_alloc_log_handle(
 701             dip, name, errlevel, mask, instance_filter, show_label, flags));
 702 }
 703
 704
 705 void
 706 usb_free_log_handle(usb_log_handle_t handle)
 707 {
 708         usba10_usb_free_log_handle(handle);
 709 }
 710
 711
 712 int
 713 usb_log(
 714         usb_log_handle_t handle,
 715         uint_t          level,
 716         uint_t          mask,
 717         char            *fmt, ...)
 718 {
 719         va_list ap;
 720         int rval;
 721
 722         va_start(ap, fmt);
 723         rval = usba10_usba_vlog(handle, level, mask, fmt, ap);
 724         va_end(ap);
 725
 726         return (rval);
 727 }
 728
 729
 730
 731 int
 732 usb_log_descr_tree(
 733         usb_client_dev_data_t   *dev_data,
 734         usb_log_handle_t        log_handle,
 735         uint_t                  level,
 736         uint_t                  mask)
 737 {
 738         return (usba10_usb_log_descr_tree(dev_data, log_handle, level, mask));
 739 }
 740
 741
 742 int
 743 usb_print_descr_tree(
 744         dev_info_t              *dip,
 745         usb_client_dev_data_t   *dev_data)
 746 {
 747         return (usba10_usb_print_descr_tree(dip, dev_data));
 748 }
 749
 750
 751 int
 752 usb_check_same_device(
 753         dev_info_t              *dip,
 754         usb_log_handle_t        log_handle,
 755         int                     log_level,
 756         int                     log_mask,
 757         uint_t                  check_mask,
 758         char                    *device_string)
 759 {
 760         return (usba10_usb_check_same_device(
 761             dip, log_handle, log_level, log_mask, check_mask, device_string));
 762 }
 763
 764
 765 const char *
 766 usb_str_cr(usb_cr_t cr)
 767 {
 768         return (usba10_usb_str_cr(cr));
 769 }
 770
 771
 772 char *
 773 usb_str_cb_flags(
 774         usb_cb_flags_t cb_flags,
 775         char *buffer,
 776         size_t length)
 777 {
 778         return (usba10_usb_str_cb_flags(cb_flags, buffer, length));
 779 }
 780
 781
 782 const char *
 783 usb_str_pipe_state(usb_pipe_state_t state)
 784 {
 785         return (usba10_usb_str_pipe_state(state));
 786 }
 787
 788
 789 const char *
 790 usb_str_dev_state(int state)
 791 {
 792         return (usba10_usb_str_dev_state(state));
 793 }
 794
 795
 796 const char *
 797 usb_str_rval(int rval)
 798 {
 799         return (usba10_usb_str_rval(rval));
 800 }
 801
 802
 803 int
 804 usb_rval2errno(int rval)
 805 {
 806         return (usba10_usb_rval2errno(rval));
 807 }
 808
 809
 810 usb_serialization_t
 811 usb_init_serialization(
 812         dev_info_t      *s_dip,
 813         uint_t          flag)
 814 {
 815         return (usba10_usb_init_serialization(s_dip, flag));
 816 }
 817
 818
 819 void
 820 usb_fini_serialization(usb_serialization_t usb_serp)
 821 {
 822         usba10_usb_fini_serialization(usb_serp);
 823 }
 824
 825
 826 int
 827 usb_serialize_access(
 828         usb_serialization_t     usb_serp,
 829         uint_t                  how_to_wait,
 830         uint_t                  delta_timeout)
 831 {
 832         return (usba10_usb_serialize_access(
 833             usb_serp, how_to_wait, delta_timeout));
 834 }
 835
 836
 837 int
 838 usb_try_serialize_access(
 839         usb_serialization_t usb_serp,
 840         uint_t flag)
 841 {
 842         return (usba10_usb_try_serialize_access(usb_serp, flag));
 843 }
 844
 845
 846 void
 847 usb_release_access(usb_serialization_t usb_serp)
 848 {
 849         usba10_usb_release_access(usb_serp);
 850 }
 851