include/linux/libata.h

   1 /*
   2    Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
   3    Copyright 2003-2004 Jeff Garzik
   4
   5    The contents of this file are subject to the Open
   6    Software License version 1.1 that can be found at
   7    http://www.opensource.org/licenses/osl-1.1.txt and is included herein
   8    by reference.
   9
  10    Alternatively, the contents of this file may be used under the terms
  11    of the GNU General Public License version 2 (the "GPL") as distributed
  12    in the kernel source COPYING file, in which case the provisions of
  13    the GPL are applicable instead of the above.  If you wish to allow
  14    the use of your version of this file only under the terms of the
  15    GPL and not to allow others to use your version of this file under
  16    the OSL, indicate your decision by deleting the provisions above and
  17    replace them with the notice and other provisions required by the GPL.
  18    If you do not delete the provisions above, a recipient may use your
  19    version of this file under either the OSL or the GPL.
  20
  21  */
  22
  23 #ifndef __LINUX_LIBATA_H__
  24 #define __LINUX_LIBATA_H__
  25
  26 #include <linux/delay.h>
  27 #include <linux/interrupt.h>
  28 #include <asm/io.h>
  29 #include <linux/ata.h>
  30 #include <linux/workqueue.h>
  31
  32 /*
  33  * compile-time options
  34  */
  35 #undef ATA_FORCE_PIO            /* do not configure or use DMA */
  36 #undef ATA_DEBUG                /* debugging output */
  37 #undef ATA_VERBOSE_DEBUG        /* yet more debugging output */
  38 #undef ATA_IRQ_TRAP             /* define to ack screaming irqs */
  39 #undef ATA_NDEBUG               /* define to disable quick runtime checks */
  40 #undef ATA_ENABLE_ATAPI         /* define to enable ATAPI support */
  41 #undef ATA_ENABLE_PATA          /* define to enable PATA support in some
  42                                  * low-level drivers */
  43 #undef ATAPI_ENABLE_DMADIR      /* enables ATAPI DMADIR bridge support */
  44
  45
  46 /* note: prints function name for you */
  47 #ifdef ATA_DEBUG
  48 #define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  49 #ifdef ATA_VERBOSE_DEBUG
  50 #define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  51 #else
  52 #define VPRINTK(fmt, args...)
  53 #endif  /* ATA_VERBOSE_DEBUG */
  54 #else
  55 #define DPRINTK(fmt, args...)
  56 #define VPRINTK(fmt, args...)
  57 #endif  /* ATA_DEBUG */
  58
  59 #ifdef ATA_NDEBUG
  60 #define assert(expr)
  61 #else
  62 #define assert(expr) \
  63         if(unlikely(!(expr))) {                                   \
  64         printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \
  65         #expr,__FILE__,__FUNCTION__,__LINE__);          \
  66         }
  67 #endif
  68
  69 /* defines only for the constants which don't work well as enums */
  70 #define ATA_TAG_POISON          0xfafbfcfdU
  71
  72 enum {
  73         /* various global constants */
  74         LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
  75         ATA_MAX_PORTS           = 8,
  76         ATA_DEF_QUEUE           = 1,
  77         ATA_MAX_QUEUE           = 1,
  78         ATA_MAX_SECTORS         = 200,  /* FIXME */
  79         ATA_MAX_BUS             = 2,
  80         ATA_DEF_BUSY_WAIT       = 10000,
  81         ATA_SHORT_PAUSE         = (HZ >> 6) + 1,
  82
  83         ATA_SHT_EMULATED        = 1,
  84         ATA_SHT_CMD_PER_LUN     = 1,
  85         ATA_SHT_THIS_ID         = -1,
  86         ATA_SHT_USE_CLUSTERING  = 0,
  87
  88         /* struct ata_device stuff */
  89         ATA_DFLAG_LBA48         = (1 << 0), /* device supports LBA48 */
  90         ATA_DFLAG_PIO           = (1 << 1), /* device currently in PIO mode */
  91         ATA_DFLAG_MASTER        = (1 << 2), /* is device 0? */
  92         ATA_DFLAG_WCACHE        = (1 << 3), /* has write cache we can
  93                                              * (hopefully) flush? */
  94
  95         ATA_DEV_UNKNOWN         = 0,    /* unknown device */
  96         ATA_DEV_ATA             = 1,    /* ATA device */
  97         ATA_DEV_ATA_UNSUP       = 2,    /* ATA device (unsupported) */
  98         ATA_DEV_ATAPI           = 3,    /* ATAPI device */
  99         ATA_DEV_ATAPI_UNSUP     = 4,    /* ATAPI device (unsupported) */
 100         ATA_DEV_NONE            = 5,    /* no device */
 101
 102         /* struct ata_port flags */
 103         ATA_FLAG_SLAVE_POSS     = (1 << 1), /* host supports slave dev */
 104                                             /* (doesn't imply presence) */
 105         ATA_FLAG_PORT_DISABLED  = (1 << 2), /* port is disabled, ignore it */
 106         ATA_FLAG_SATA           = (1 << 3),
 107         ATA_FLAG_NO_LEGACY      = (1 << 4), /* no legacy mode check */
 108         ATA_FLAG_SRST           = (1 << 5), /* use ATA SRST, not E.D.D. */
 109         ATA_FLAG_MMIO           = (1 << 6), /* use MMIO, not PIO */
 110         ATA_FLAG_SATA_RESET     = (1 << 7), /* use COMRESET */
 111
 112         ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
 113         ATA_QCFLAG_DMA          = (1 << 2), /* data delivered via DMA */
 114         ATA_QCFLAG_SG           = (1 << 4), /* have s/g table? */
 115
 116         /* various lengths of time */
 117         ATA_TMOUT_EDD           = 5 * HZ,       /* hueristic */
 118         ATA_TMOUT_PIO           = 30 * HZ,
 119         ATA_TMOUT_BOOT          = 30 * HZ,      /* hueristic */
 120         ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* hueristic */
 121         ATA_TMOUT_CDB           = 30 * HZ,
 122         ATA_TMOUT_CDB_QUICK     = 5 * HZ,
 123
 124         /* ATA bus states */
 125         BUS_UNKNOWN             = 0,
 126         BUS_DMA                 = 1,
 127         BUS_IDLE                = 2,
 128         BUS_NOINTR              = 3,
 129         BUS_NODATA              = 4,
 130         BUS_TIMER               = 5,
 131         BUS_PIO                 = 6,
 132         BUS_EDD                 = 7,
 133         BUS_IDENTIFY            = 8,
 134         BUS_PACKET              = 9,
 135
 136         /* thread states */
 137         THR_UNKNOWN             = 0,
 138         THR_PORT_RESET          = (THR_UNKNOWN + 1),
 139         THR_AWAIT_DEATH         = (THR_PORT_RESET + 1),
 140         THR_PROBE_FAILED        = (THR_AWAIT_DEATH + 1),
 141         THR_IDLE                = (THR_PROBE_FAILED + 1),
 142         THR_PROBE_SUCCESS       = (THR_IDLE + 1),
 143         THR_PROBE_START         = (THR_PROBE_SUCCESS + 1),
 144
 145         /* SATA port states */
 146         PORT_UNKNOWN            = 0,
 147         PORT_ENABLED            = 1,
 148         PORT_DISABLED           = 2,
 149
 150         /* ata_qc_cb_t flags - note uses above ATA_QCFLAG_xxx namespace,
 151          * but not numberspace
 152          */
 153         ATA_QCFLAG_TIMEOUT      = (1 << 0),
 154 };
 155
 156 enum pio_task_states {
 157         PIO_ST_UNKNOWN,
 158         PIO_ST_IDLE,
 159         PIO_ST_POLL,
 160         PIO_ST_TMOUT,
 161         PIO_ST,
 162         PIO_ST_LAST,
 163         PIO_ST_LAST_POLL,
 164         PIO_ST_ERR,
 165 };
 166
 167 /* forward declarations */
 168 struct scsi_device;
 169 struct ata_port_operations;
 170 struct ata_port;
 171 struct ata_queued_cmd;
 172
 173 /* typedefs */
 174 typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc, unsigned int flags);
 175
 176 struct ata_ioports {
 177         unsigned long           cmd_addr;
 178         unsigned long           data_addr;
 179         unsigned long           error_addr;
 180         unsigned long           feature_addr;
 181         unsigned long           nsect_addr;
 182         unsigned long           lbal_addr;
 183         unsigned long           lbam_addr;
 184         unsigned long           lbah_addr;
 185         unsigned long           device_addr;
 186         unsigned long           status_addr;
 187         unsigned long           command_addr;
 188         unsigned long           altstatus_addr;
 189         unsigned long           ctl_addr;
 190         unsigned long           bmdma_addr;
 191         unsigned long           scr_addr;
 192 };
 193
 194 struct ata_probe_ent {
 195         struct list_head        node;
 196         struct pci_dev          *pdev;
 197         struct ata_port_operations      *port_ops;
 198         Scsi_Host_Template      *sht;
 199         struct ata_ioports      port[ATA_MAX_PORTS];
 200         unsigned int            n_ports;
 201         unsigned int            pio_mask;
 202         unsigned int            udma_mask;
 203         unsigned int            legacy_mode;
 204         unsigned long           irq;
 205         unsigned int            irq_flags;
 206         unsigned long           host_flags;
 207         void                    *mmio_base;
 208         void                    *private_data;
 209 };
 210
 211 struct ata_host_set {
 212         spinlock_t              lock;
 213         struct pci_dev          *pdev;
 214         unsigned long           irq;
 215         void                    *mmio_base;
 216         unsigned int            n_ports;
 217         void                    *private_data;
 218         struct ata_port *       ports[0];
 219 };
 220
 221 struct ata_queued_cmd {
 222         struct ata_port         *ap;
 223         struct ata_device       *dev;
 224
 225         struct scsi_cmnd        *scsicmd;
 226         void                    (*scsidone)(struct scsi_cmnd *);
 227
 228         unsigned long           flags;          /* ATA_QCFLAG_xxx */
 229         unsigned int            tag;
 230         unsigned int            n_elem;
 231         unsigned int            nsect;
 232         unsigned int            cursect;
 233         unsigned int            cursg;
 234         unsigned int            cursg_ofs;
 235         struct ata_taskfile     tf;
 236         struct scatterlist      sgent;
 237
 238         struct scatterlist      *sg;
 239
 240         ata_qc_cb_t             callback;
 241
 242         struct completion       *waiting;
 243
 244         void                    *private_data;
 245 };
 246
 247 struct ata_host_stats {
 248         unsigned long           unhandled_irq;
 249         unsigned long           idle_irq;
 250         unsigned long           rw_reqbuf;
 251 };
 252
 253 struct ata_device {
 254         u64                     n_sectors;      /* size of device, if ATA */
 255         unsigned long           flags;          /* ATA_DFLAG_xxx */
 256         unsigned int            class;          /* ATA_DEV_xxx */
 257         unsigned int            devno;          /* 0 or 1 */
 258         u16                     id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
 259         unsigned int            pio_mode;
 260         unsigned int            udma_mode;
 261
 262         /* cache info about current transfer mode */
 263         u8                      xfer_protocol;  /* taskfile xfer protocol */
 264         u8                      read_cmd;       /* opcode to use on read */
 265         u8                      write_cmd;      /* opcode to use on write */
 266 };
 267
 268 struct ata_port {
 269         struct Scsi_Host        *host;  /* our co-allocated scsi host */
 270         struct ata_port_operations      *ops;
 271         unsigned long           flags;  /* ATA_FLAG_xxx */
 272         unsigned int            id;     /* unique id req'd by scsi midlyr */
 273         unsigned int            port_no; /* unique port #; from zero */
 274
 275         struct ata_prd          *prd;    /* our SG list */
 276         dma_addr_t              prd_dma; /* and its DMA mapping */
 277
 278         struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
 279
 280         u8                      ctl;    /* cache of ATA control register */
 281         u8                      last_ctl;       /* Cache last written value */
 282         unsigned int            bus_state;
 283         unsigned int            port_state;
 284         unsigned int            pio_mask;
 285         unsigned int            udma_mask;
 286         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
 287
 288         struct ata_device       device[ATA_MAX_DEVICES];
 289
 290         struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
 291         unsigned long           qactive;
 292         unsigned int            active_tag;
 293
 294         struct ata_host_stats   stats;
 295         struct ata_host_set     *host_set;
 296
 297         struct semaphore        probe_sem;
 298
 299         unsigned int            thr_state;
 300
 301         struct work_struct      packet_task;
 302
 303         struct work_struct      pio_task;
 304         unsigned int            pio_task_state;
 305         unsigned long           pio_task_timeout;
 306
 307         struct work_struct      probe_task;
 308
 309         void                    *private_data;
 310 };
 311
 312 struct ata_port_operations {
 313         void (*port_disable) (struct ata_port *);
 314
 315         void (*dev_config) (struct ata_port *, struct ata_device *);
 316
 317         void (*set_piomode) (struct ata_port *, struct ata_device *,
 318                              unsigned int);
 319         void (*set_udmamode) (struct ata_port *, struct ata_device *,
 320                              unsigned int);
 321
 322         void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
 323         void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
 324
 325         void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
 326         u8   (*check_status)(struct ata_port *ap);
 327
 328         void (*phy_reset) (struct ata_port *ap);
 329         void (*post_set_mode) (struct ata_port *ap);
 330
 331         void (*bmdma_setup) (struct ata_queued_cmd *qc);
 332         void (*bmdma_start) (struct ata_queued_cmd *qc);
 333         void (*fill_sg) (struct ata_queued_cmd *qc);
 334         void (*eng_timeout) (struct ata_port *ap);
 335
 336         irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
 337
 338         u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
 339         void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
 340                            u32 val);
 341
 342         int (*port_start) (struct ata_port *ap);
 343         void (*port_stop) (struct ata_port *ap);
 344
 345         void (*host_stop) (struct ata_host_set *host_set);
 346 };
 347
 348 struct ata_port_info {
 349         Scsi_Host_Template      *sht;
 350         unsigned long           host_flags;
 351         unsigned long           pio_mask;
 352         unsigned long           udma_mask;
 353         struct ata_port_operations      *port_ops;
 354 };
 355
 356 struct pci_bits {
 357         unsigned int            reg;    /* PCI config register to read */
 358         unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
 359         unsigned long           mask;
 360         unsigned long           val;
 361 };
 362
 363 extern void ata_port_probe(struct ata_port *);
 364 extern void sata_phy_reset(struct ata_port *ap);
 365 extern void ata_bus_reset(struct ata_port *ap);
 366 extern void ata_port_disable(struct ata_port *);
 367 extern void ata_std_ports(struct ata_ioports *ioaddr);
 368 extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 369                              unsigned int n_ports);
 370 extern void ata_pci_remove_one (struct pci_dev *pdev);
 371 extern int ata_device_add(struct ata_probe_ent *ent);
 372 extern int ata_scsi_detect(Scsi_Host_Template *sht);
 373 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
 374 extern int ata_scsi_error(struct Scsi_Host *host);
 375 extern int ata_scsi_release(struct Scsi_Host *host);
 376 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
 377 /*
 378  * Default driver ops implementations
 379  */
 380 extern void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf);
 381 extern void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 382 extern void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf);
 383 extern void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 384 extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp);
 385 extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf);
 386 extern u8 ata_check_status_pio(struct ata_port *ap);
 387 extern u8 ata_check_status_mmio(struct ata_port *ap);
 388 extern void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf);
 389 extern void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 390 extern int ata_port_start (struct ata_port *ap);
 391 extern void ata_port_stop (struct ata_port *ap);
 392 extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
 393 extern void ata_fill_sg(struct ata_queued_cmd *qc);
 394 extern void ata_dev_id_string(struct ata_device *dev, unsigned char *s,
 395                               unsigned int ofs, unsigned int len);
 396 extern void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc);
 397 extern void ata_bmdma_start_mmio (struct ata_queued_cmd *qc);
 398 extern void ata_bmdma_setup_pio (struct ata_queued_cmd *qc);
 399 extern void ata_bmdma_start_pio (struct ata_queued_cmd *qc);
 400 extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
 401 extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat);
 402 extern void ata_eng_timeout(struct ata_port *ap);
 403 extern int ata_std_bios_param(struct scsi_device *sdev,
 404                               struct block_device *bdev,
 405                               sector_t capacity, int geom[]);
 406 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 407
 408
 409 static inline unsigned int ata_tag_valid(unsigned int tag)
 410 {
 411         return (tag < ATA_MAX_QUEUE) ? 1 : 0;
 412 }
 413
 414 static inline unsigned int ata_dev_present(struct ata_device *dev)
 415 {
 416         return ((dev->class == ATA_DEV_ATA) ||
 417                 (dev->class == ATA_DEV_ATAPI));
 418 }
 419
 420 static inline u8 ata_chk_err(struct ata_port *ap)
 421 {
 422         if (ap->flags & ATA_FLAG_MMIO) {
 423                 return readb((void *) ap->ioaddr.error_addr);
 424         }
 425         return inb(ap->ioaddr.error_addr);
 426 }
 427
 428 static inline u8 ata_chk_status(struct ata_port *ap)
 429 {
 430         return ap->ops->check_status(ap);
 431 }
 432
 433 static inline u8 ata_altstatus(struct ata_port *ap)
 434 {
 435         if (ap->flags & ATA_FLAG_MMIO)
 436                 return readb(ap->ioaddr.altstatus_addr);
 437         return inb(ap->ioaddr.altstatus_addr);
 438 }
 439
 440 static inline void ata_pause(struct ata_port *ap)
 441 {
 442         ata_altstatus(ap);
 443         ndelay(400);
 444 }
 445
 446 static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
 447                                unsigned int max)
 448 {
 449         u8 status;
 450
 451         do {
 452                 udelay(10);
 453                 status = ata_chk_status(ap);
 454                 max--;
 455         } while ((status & bits) && (max > 0));
 456
 457         return status;
 458 }
 459
 460 static inline u8 ata_wait_idle(struct ata_port *ap)
 461 {
 462         u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
 463
 464         if (status & (ATA_BUSY | ATA_DRQ)) {
 465                 unsigned long l = ap->ioaddr.status_addr;
 466                 printk(KERN_WARNING
 467                        "ATA: abnormal status 0x%X on port 0x%lX\n",
 468                        status, l);
 469         }
 470
 471         return status;
 472 }
 473
 474 static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
 475 {
 476         qc->flags &= ~ATA_QCFLAG_DMA;
 477         qc->tf.ctl |= ATA_NIEN;
 478 }
 479
 480 static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
 481                                                       unsigned int tag)
 482 {
 483         if (likely(ata_tag_valid(tag)))
 484                 return &ap->qcmd[tag];
 485         return NULL;
 486 }
 487
 488 static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
 489 {
 490         memset(tf, 0, sizeof(*tf));
 491
 492         tf->ctl = ap->ctl;
 493         if (device == 0)
 494                 tf->device = ATA_DEVICE_OBS;
 495         else
 496                 tf->device = ATA_DEVICE_OBS | ATA_DEV1;
 497 }
 498
 499 static inline u8 ata_irq_on(struct ata_port *ap)
 500 {
 501         struct ata_ioports *ioaddr = &ap->ioaddr;
 502
 503         ap->ctl &= ~ATA_NIEN;
 504         ap->last_ctl = ap->ctl;
 505
 506         if (ap->flags & ATA_FLAG_MMIO)
 507                 writeb(ap->ctl, ioaddr->ctl_addr);
 508         else
 509                 outb(ap->ctl, ioaddr->ctl_addr);
 510         return ata_wait_idle(ap);
 511 }
 512
 513 static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
 514 {
 515         unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
 516         u8 host_stat, post_stat, status;
 517
 518         status = ata_busy_wait(ap, bits, 1000);
 519         if (status & bits)
 520                 DPRINTK("abnormal status 0x%X\n", status);
 521
 522         /* get controller status; clear intr, err bits */
 523         if (ap->flags & ATA_FLAG_MMIO) {
 524                 void *mmio = (void *) ap->ioaddr.bmdma_addr;
 525                 host_stat = readb(mmio + ATA_DMA_STATUS);
 526                 writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 527                        mmio + ATA_DMA_STATUS);
 528
 529                 post_stat = readb(mmio + ATA_DMA_STATUS);
 530         } else {
 531                 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 532                 outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 533                      ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 534
 535                 post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 536         }
 537
 538         VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
 539                 host_stat, post_stat, status);
 540
 541         return status;
 542 }
 543
 544 static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
 545 {
 546         return ap->ops->scr_read(ap, reg);
 547 }
 548
 549 static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
 550 {
 551         ap->ops->scr_write(ap, reg, val);
 552 }
 553
 554 static inline unsigned int sata_dev_present(struct ata_port *ap)
 555 {
 556         return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
 557 }
 558
 559 #endif /* __LINUX_LIBATA_H__ */