~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

// debug ("rio_node_id: %x\nbbar: %x\nrio_type: %x\nowner_id: %x\nport0_node: %x\nport0_port: %x\nport1_node: %x\nport1_port: %x\nfirst_slot_num: %x\nstatus: %x\n", rio_detail_ptr->rio_node_id, rio_detail_ptr->bbar, rio_detail_ptr->rio_type, rio_detail_ptr->owner_id, rio_detail_ptr->port0_node_connect, rio_detail_ptr->port0_port_connect, rio_detail_ptr->port1_node_connect, rio_detail_ptr->port1_port_connect, rio_detail_ptr->first_slot_num, rio_detail_ptr->status);

440

//create linked list of chassis

441

if (rio_detail_ptr->rio_type == 4 || rio_detail_ptr->rio_type == 5)

442

list_add (&rio_detail_ptr->rio_detail_list, &rio_vg_head);

443

//create linked list of expansion box

444

else if (rio_detail_ptr->rio_type == 6 || rio_detail_ptr->rio_type == 7)

445

list_add (&rio_detail_ptr->rio_detail_list, &rio_lo_head);

446

else

447

// not in my concern

448

kfree (rio_detail_ptr);

449

offset += 15;

450

}

451

print_lo_info ();

452

print_vg_info ();

453

return 0;

454

}

455

456

457

* reorganizing linked list of chassis

458

459

static struct opt_rio *search_opt_vg (u8 chassis_num)

460

{

461

struct opt_rio *ptr;

462

list_for_each_entry(ptr, &opt_vg_head, opt_rio_list) {

463

if (ptr->chassis_num == chassis_num)

464

return ptr;

465

}

466

return NULL;

467

}

468

469

static int __init combine_wpg_for_chassis (void)

470

{

471

struct opt_rio *opt_rio_ptr = NULL;

472

struct rio_detail *rio_detail_ptr = NULL;

473

474

list_for_each_entry(rio_detail_ptr, &rio_vg_head, rio_detail_list) {

475

opt_rio_ptr = search_opt_vg (rio_detail_ptr->chassis_num);

476

if (!opt_rio_ptr) {

477

opt_rio_ptr = kzalloc(sizeof(struct opt_rio), GFP_KERNEL);

478

if (!opt_rio_ptr)

479

return -ENOMEM;

480

opt_rio_ptr->rio_type = rio_detail_ptr->rio_type;

481

opt_rio_ptr->chassis_num = rio_detail_ptr->chassis_num;

482

opt_rio_ptr->first_slot_num = rio_detail_ptr->first_slot_num;

483

opt_rio_ptr->middle_num = rio_detail_ptr->first_slot_num;

484

list_add (&opt_rio_ptr->opt_rio_list, &opt_vg_head);

485

} else {

486

opt_rio_ptr->first_slot_num = min (opt_rio_ptr->first_slot_num, rio_detail_ptr->first_slot_num);

487

opt_rio_ptr->middle_num = max (opt_rio_ptr->middle_num, rio_detail_ptr->first_slot_num);

488

}

489

}

490

print_opt_vg ();

491

return 0;

492

}

493

494

495

* reorganizing linked list of expansion box

496

497

static struct opt_rio_lo *search_opt_lo (u8 chassis_num)

498

{

499

struct opt_rio_lo *ptr;

500

list_for_each_entry(ptr, &opt_lo_head, opt_rio_lo_list) {

501

if (ptr->chassis_num == chassis_num)

502

return ptr;

503

}

504

return NULL;

505

}

506

507

static int combine_wpg_for_expansion (void)

508

{

509

struct opt_rio_lo *opt_rio_lo_ptr = NULL;

510

struct rio_detail *rio_detail_ptr = NULL;

511

512

list_for_each_entry(rio_detail_ptr, &rio_lo_head, rio_detail_list) {

513

opt_rio_lo_ptr = search_opt_lo (rio_detail_ptr->chassis_num);

514

if (!opt_rio_lo_ptr) {

515

opt_rio_lo_ptr = kzalloc(sizeof(struct opt_rio_lo), GFP_KERNEL);

516

if (!opt_rio_lo_ptr)

517

return -ENOMEM;

518

opt_rio_lo_ptr->rio_type = rio_detail_ptr->rio_type;

519

opt_rio_lo_ptr->chassis_num = rio_detail_ptr->chassis_num;

520

opt_rio_lo_ptr->first_slot_num = rio_detail_ptr->first_slot_num;

521

opt_rio_lo_ptr->middle_num = rio_detail_ptr->first_slot_num;

522

opt_rio_lo_ptr->pack_count = 1;

523

524

list_add (&opt_rio_lo_ptr->opt_rio_lo_list, &opt_lo_head);

525

} else {

526

opt_rio_lo_ptr->first_slot_num = min (opt_rio_lo_ptr->first_slot_num, rio_detail_ptr->first_slot_num);

527

opt_rio_lo_ptr->middle_num = max (opt_rio_lo_ptr->middle_num, rio_detail_ptr->first_slot_num);

528

opt_rio_lo_ptr->pack_count = 2;

529

}

530

}

531

return 0;

532

}

533

534

535

/* Since we don't know the max slot number per each chassis, hence go

536

* through the list of all chassis to find out the range

537

* Arguments: slot_num, 1st slot number of the chassis we think we are on,

538

* var (0 = chassis, 1 = expansion box)

539

540

static int first_slot_num (u8 slot_num, u8 first_slot, u8 var)

541

{

542

struct opt_rio *opt_vg_ptr = NULL;

543

struct opt_rio_lo *opt_lo_ptr = NULL;

544

int rc = 0;

545

546

if (!var) {

547

list_for_each_entry(opt_vg_ptr, &opt_vg_head, opt_rio_list) {

548

if ((first_slot < opt_vg_ptr->first_slot_num) && (slot_num >= opt_vg_ptr->first_slot_num)) {

549

rc = -ENODEV;

550

break;

551

}

552

}

553

} else {

554

list_for_each_entry(opt_lo_ptr, &opt_lo_head, opt_rio_lo_list) {

555

if ((first_slot < opt_lo_ptr->first_slot_num) && (slot_num >= opt_lo_ptr->first_slot_num)) {

556

rc = -ENODEV;

557

break;

558

}

559

}

560

}

561

return rc;

562

}

563

564

static struct opt_rio_lo * find_rxe_num (u8 slot_num)

565

{

566

struct opt_rio_lo *opt_lo_ptr;

567

568

list_for_each_entry(opt_lo_ptr, &opt_lo_head, opt_rio_lo_list) {

569

//check to see if this slot_num belongs to expansion box

570

if ((slot_num >= opt_lo_ptr->first_slot_num) && (!first_slot_num (slot_num, opt_lo_ptr->first_slot_num, 1)))

571

return opt_lo_ptr;

572

}

573

return NULL;

574

}

575

576

static struct opt_rio * find_chassis_num (u8 slot_num)

577

{

578

struct opt_rio *opt_vg_ptr;

579

580

list_for_each_entry(opt_vg_ptr, &opt_vg_head, opt_rio_list) {

581

//check to see if this slot_num belongs to chassis

582

if ((slot_num >= opt_vg_ptr->first_slot_num) && (!first_slot_num (slot_num, opt_vg_ptr->first_slot_num, 0)))

583

return opt_vg_ptr;

584

}

585

return NULL;

586

}

587

588

/* This routine will find out how many slots are in the chassis, so that

589

* the slot numbers for rxe100 would start from 1, and not from 7, or 6 etc

590

591

static u8 calculate_first_slot (u8 slot_num)

592

{

593

u8 first_slot = 1;

594

struct slot * slot_cur;

595

596

list_for_each_entry(slot_cur, &ibmphp_slot_head, ibm_slot_list) {

597

if (slot_cur->ctrl) {

598

if ((slot_cur->ctrl->ctlr_type != 4) && (slot_cur->ctrl->ending_slot_num > first_slot) && (slot_num > slot_cur->ctrl->ending_slot_num))

599

first_slot = slot_cur->ctrl->ending_slot_num;

600

}

601

}

602

return first_slot + 1;

603

604

}

605

606

#define SLOT_NAME_SIZE 30

607

608

static char *create_file_name (struct slot * slot_cur)

609

{

610

struct opt_rio *opt_vg_ptr = NULL;

611

struct opt_rio_lo *opt_lo_ptr = NULL;

612

static char str[SLOT_NAME_SIZE];

613

int which = 0; /* rxe = 1, chassis = 0 */

614

u8 number = 1; /* either chassis or rxe # */

615

u8 first_slot = 1;

616

u8 slot_num;

617

u8 flag = 0;

618

619

if (!slot_cur) {

620

err ("Structure passed is empty\n");

621

return NULL;

622

}

623

624

slot_num = slot_cur->number;

625

626

memset (str, 0, sizeof(str));

627

628

if (rio_table_ptr) {

629

if (rio_table_ptr->ver_num == 3) {

630

opt_vg_ptr = find_chassis_num (slot_num);

631

opt_lo_ptr = find_rxe_num (slot_num);

632

}

633

}

634

if (opt_vg_ptr) {

635

if (opt_lo_ptr) {

636

if ((slot_num - opt_vg_ptr->first_slot_num) > (slot_num - opt_lo_ptr->first_slot_num)) {

637

number = opt_lo_ptr->chassis_num;

638

first_slot = opt_lo_ptr->first_slot_num;

639

which = 1; /* it is RXE */

640

} else {

641

first_slot = opt_vg_ptr->first_slot_num;

642

number = opt_vg_ptr->chassis_num;

643

which = 0;

644

}

645

} else {

646

first_slot = opt_vg_ptr->first_slot_num;

647

number = opt_vg_ptr->chassis_num;

648

which = 0;

649

}

650

++flag;

651

} else if (opt_lo_ptr) {

652

number = opt_lo_ptr->chassis_num;

653

first_slot = opt_lo_ptr->first_slot_num;

654

which = 1;

655

++flag;

656

} else if (rio_table_ptr) {

657

if (rio_table_ptr->ver_num == 3) {

658

/* if both NULL and we DO have correct RIO table in BIOS */

659

return NULL;

660

}

661

}

662

if (!flag) {

663

if (slot_cur->ctrl->ctlr_type == 4) {

664

first_slot = calculate_first_slot (slot_num);

665

which = 1;

666

} else {

667

which = 0;

668

}

669

}

670

671

sprintf(str, "%s%dslot%d",

672

which == 0 ? "chassis" : "rxe",

673

number, slot_num - first_slot + 1);

674

return str;

675

}

676

677

static int fillslotinfo(struct hotplug_slot *hotplug_slot)

678

{

679

struct slot *slot;

680

int rc = 0;

681

682

if (!hotplug_slot || !hotplug_slot->private)

683

return -EINVAL;

684

685

slot = hotplug_slot->private;

686

rc = ibmphp_hpc_readslot(slot, READ_ALLSTAT, NULL);

687

if (rc)

688

return rc;

689

690

// power - enabled:1 not:0

691

hotplug_slot->info->power_status = SLOT_POWER(slot->status);

692

693

// attention - off:0, on:1, blinking:2

694

hotplug_slot->info->attention_status = SLOT_ATTN(slot->status, slot->ext_status);

695

696

// latch - open:1 closed:0

697

hotplug_slot->info->latch_status = SLOT_LATCH(slot->status);

698

699

// pci board - present:1 not:0

700

if (SLOT_PRESENT (slot->status))

701

hotplug_slot->info->adapter_status = 1;

702

else

703

hotplug_slot->info->adapter_status = 0;

704

705

if (slot->bus_on->supported_bus_mode

706

&& (slot->bus_on->supported_speed == BUS_SPEED_66))

707

hotplug_slot->info->max_bus_speed_status = BUS_SPEED_66PCIX;

708

else

709

hotplug_slot->info->max_bus_speed_status = slot->bus_on->supported_speed;

710

711

712

return rc;

713

}

714

715

static void release_slot(struct hotplug_slot *hotplug_slot)

716

{

717

struct slot *slot;

718

719

if (!hotplug_slot || !hotplug_slot->private)

720

return;

721

722

slot = hotplug_slot->private;

723

kfree(slot->hotplug_slot->info);

724

kfree(slot->hotplug_slot);

725

slot->ctrl = NULL;

726

slot->bus_on = NULL;

727

728

/* we don't want to actually remove the resources, since free_resources will do just that */

729

ibmphp_unconfigure_card(&slot, -1);

730

731

kfree (slot);

732

}

733

734

static struct pci_driver ibmphp_driver;

735

736

737

* map info (ctlr-id, slot count, slot#.. bus count, bus#, ctlr type...) of

738

* each hpc from physical address to a list of hot plug controllers based on

739

* hpc descriptors.

740

741

static int __init ebda_rsrc_controller (void)

742

{

743

u16 addr, addr_slot, addr_bus;

744

u8 ctlr_id, temp, bus_index;

745

u16 ctlr, slot, bus;

746

u16 slot_num, bus_num, index;

747

struct hotplug_slot *hp_slot_ptr;

748

struct controller *hpc_ptr;

749

struct ebda_hpc_bus *bus_ptr;

750

struct ebda_hpc_slot *slot_ptr;

751

struct bus_info *bus_info_ptr1, *bus_info_ptr2;

752

int rc;

753

struct slot *tmp_slot;

754

char name[SLOT_NAME_SIZE];

755

756

addr = hpc_list_ptr->phys_addr;

757

for (ctlr = 0; ctlr < hpc_list_ptr->num_ctlrs; ctlr++) {

758

bus_index = 1;

759

ctlr_id = readb (io_mem + addr);

760

addr += 1;

761

slot_num = readb (io_mem + addr);

762

763

addr += 1;

764

addr_slot = addr; /* offset of slot structure */

765

addr += (slot_num * 4);

766

767

bus_num = readb (io_mem + addr);

768

769

addr += 1;

770

addr_bus = addr; /* offset of bus */

771

addr += (bus_num * 9); /* offset of ctlr_type */

772

temp = readb (io_mem + addr);

773

774

addr += 1;

775

/* init hpc structure */

776

hpc_ptr = alloc_ebda_hpc (slot_num, bus_num);

777

if (!hpc_ptr ) {

778

rc = -ENOMEM;

779

goto error_no_hpc;

780

}

781

hpc_ptr->ctlr_id = ctlr_id;

782

hpc_ptr->ctlr_relative_id = ctlr;

783

hpc_ptr->slot_count = slot_num;

784

hpc_ptr->bus_count = bus_num;

785

debug ("now enter ctlr data struture ---\n");

786

debug ("ctlr id: %x\n", ctlr_id);

787

debug ("ctlr_relative_id: %x\n", hpc_ptr->ctlr_relative_id);

788

debug ("count of slots controlled by this ctlr: %x\n", slot_num);

789

debug ("count of buses controlled by this ctlr: %x\n", bus_num);

790

791

/* init slot structure, fetch slot, bus, cap... */

792

slot_ptr = hpc_ptr->slots;

793

for (slot = 0; slot < slot_num; slot++) {

794

slot_ptr->slot_num = readb (io_mem + addr_slot);

795

slot_ptr->slot_bus_num = readb (io_mem + addr_slot + slot_num);

796

slot_ptr->ctl_index = readb (io_mem + addr_slot + 2*slot_num);

797

slot_ptr->slot_cap = readb (io_mem + addr_slot + 3*slot_num);

798

799

// create bus_info lined list --- if only one slot per bus: slot_min = slot_max

800

801

bus_info_ptr2 = ibmphp_find_same_bus_num (slot_ptr->slot_bus_num);

802

if (!bus_info_ptr2) {

803

bus_info_ptr1 = kzalloc(sizeof(struct bus_info), GFP_KERNEL);

804

if (!bus_info_ptr1) {

805

rc = -ENOMEM;

806

goto error_no_hp_slot;

807

}

808

bus_info_ptr1->slot_min = slot_ptr->slot_num;

809

bus_info_ptr1->slot_max = slot_ptr->slot_num;

810

bus_info_ptr1->slot_count += 1;

811

bus_info_ptr1->busno = slot_ptr->slot_bus_num;

812

bus_info_ptr1->index = bus_index++;

813

bus_info_ptr1->current_speed = 0xff;

814

bus_info_ptr1->current_bus_mode = 0xff;

815

816

bus_info_ptr1->controller_id = hpc_ptr->ctlr_id;

817

818

list_add_tail (&bus_info_ptr1->bus_info_list, &bus_info_head);

819

820

} else {

821

bus_info_ptr2->slot_min = min (bus_info_ptr2->slot_min, slot_ptr->slot_num);

822

bus_info_ptr2->slot_max = max (bus_info_ptr2->slot_max, slot_ptr->slot_num);

823

bus_info_ptr2->slot_count += 1;

824

825

}

826

827

// end of creating the bus_info linked list

828

829

slot_ptr++;

830

addr_slot += 1;

831

}

832

833

/* init bus structure */

834

bus_ptr = hpc_ptr->buses;

835

for (bus = 0; bus < bus_num; bus++) {

836

bus_ptr->bus_num = readb (io_mem + addr_bus + bus);

837

bus_ptr->slots_at_33_conv = readb (io_mem + addr_bus + bus_num + 8 * bus);

838

bus_ptr->slots_at_66_conv = readb (io_mem + addr_bus + bus_num + 8 * bus + 1);

839

840

bus_ptr->slots_at_66_pcix = readb (io_mem + addr_bus + bus_num + 8 * bus + 2);

841

842

bus_ptr->slots_at_100_pcix = readb (io_mem + addr_bus + bus_num + 8 * bus + 3);

843

844

bus_ptr->slots_at_133_pcix = readb (io_mem + addr_bus + bus_num + 8 * bus + 4);

845

846

bus_info_ptr2 = ibmphp_find_same_bus_num (bus_ptr->bus_num);

847

if (bus_info_ptr2) {

848

bus_info_ptr2->slots_at_33_conv = bus_ptr->slots_at_33_conv;

849

bus_info_ptr2->slots_at_66_conv = bus_ptr->slots_at_66_conv;

850

bus_info_ptr2->slots_at_66_pcix = bus_ptr->slots_at_66_pcix;

851

bus_info_ptr2->slots_at_100_pcix = bus_ptr->slots_at_100_pcix;

852

bus_info_ptr2->slots_at_133_pcix = bus_ptr->slots_at_133_pcix;

853

}

854

bus_ptr++;

855

}

856

857

hpc_ptr->ctlr_type = temp;

858

859

switch (hpc_ptr->ctlr_type) {

860

case 1:

861

hpc_ptr->u.pci_ctlr.bus = readb (io_mem + addr);

862

hpc_ptr->u.pci_ctlr.dev_fun = readb (io_mem + addr + 1);

863

hpc_ptr->irq = readb (io_mem + addr + 2);

864

addr += 3;

865

debug ("ctrl bus = %x, ctlr devfun = %x, irq = %x\n",

866

hpc_ptr->u.pci_ctlr.bus,

867

hpc_ptr->u.pci_ctlr.dev_fun, hpc_ptr->irq);

868

break;

869

870

case 0:

871

hpc_ptr->u.isa_ctlr.io_start = readw (io_mem + addr);

872

hpc_ptr->u.isa_ctlr.io_end = readw (io_mem + addr + 2);

873

if (!request_region (hpc_ptr->u.isa_ctlr.io_start,

874

(hpc_ptr->u.isa_ctlr.io_end - hpc_ptr->u.isa_ctlr.io_start + 1),

875

"ibmphp")) {

876

rc = -ENODEV;

877

goto error_no_hp_slot;

878

}

879

hpc_ptr->irq = readb (io_mem + addr + 4);

880

addr += 5;

881

break;

882

883

case 2:

884

case 4:

885

hpc_ptr->u.wpeg_ctlr.wpegbbar = readl (io_mem + addr);

886

hpc_ptr->u.wpeg_ctlr.i2c_addr = readb (io_mem + addr + 4);

887

hpc_ptr->irq = readb (io_mem + addr + 5);

888

addr += 6;

889

break;

890

default:

891

rc = -ENODEV;

892

goto error_no_hp_slot;

893

}

894

895

//reorganize chassis' linked list

896

combine_wpg_for_chassis ();

897

combine_wpg_for_expansion ();

898

hpc_ptr->revision = 0xff;

899

hpc_ptr->options = 0xff;

900

hpc_ptr->starting_slot_num = hpc_ptr->slots[0].slot_num;

901

hpc_ptr->ending_slot_num = hpc_ptr->slots[slot_num-1].slot_num;

902

903

// register slots with hpc core as well as create linked list of ibm slot

904

for (index = 0; index < hpc_ptr->slot_count; index++) {

905

906

hp_slot_ptr = kzalloc(sizeof(*hp_slot_ptr), GFP_KERNEL);

907

if (!hp_slot_ptr) {

908

rc = -ENOMEM;

909

goto error_no_hp_slot;

910

}

911

912

hp_slot_ptr->info = kzalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);

913

if (!hp_slot_ptr->info) {

914

rc = -ENOMEM;

915

goto error_no_hp_info;

916

}

917

918

tmp_slot = kzalloc(sizeof(*tmp_slot), GFP_KERNEL);

919

if (!tmp_slot) {

920

rc = -ENOMEM;

921

goto error_no_slot;

922

}

923

924

tmp_slot->flag = 1;

925

926

tmp_slot->capabilities = hpc_ptr->slots[index].slot_cap;

927

if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_133_MAX) == EBDA_SLOT_133_MAX)

928

tmp_slot->supported_speed = 3;

929

else if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_100_MAX) == EBDA_SLOT_100_MAX)

930

tmp_slot->supported_speed = 2;

931

else if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_66_MAX) == EBDA_SLOT_66_MAX)

932

tmp_slot->supported_speed = 1;

933

934

if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_PCIX_CAP) == EBDA_SLOT_PCIX_CAP)

935

tmp_slot->supported_bus_mode = 1;

936

else

937

tmp_slot->supported_bus_mode = 0;

938

939

940

tmp_slot->bus = hpc_ptr->slots[index].slot_bus_num;

941

942

bus_info_ptr1 = ibmphp_find_same_bus_num (hpc_ptr->slots[index].slot_bus_num);

943

if (!bus_info_ptr1) {

944

kfree(tmp_slot);

945

rc = -ENODEV;

946

goto error;

947

}

948

tmp_slot->bus_on = bus_info_ptr1;

949

bus_info_ptr1 = NULL;

950

tmp_slot->ctrl = hpc_ptr;

951

952

tmp_slot->ctlr_index = hpc_ptr->slots[index].ctl_index;

953

tmp_slot->number = hpc_ptr->slots[index].slot_num;

954

tmp_slot->hotplug_slot = hp_slot_ptr;

955

956

hp_slot_ptr->private = tmp_slot;

957

hp_slot_ptr->release = release_slot;

958

959

rc = fillslotinfo(hp_slot_ptr);

960

if (rc)

961

goto error;

962

963

rc = ibmphp_init_devno ((struct slot **) &hp_slot_ptr->private);

964

if (rc)

965

goto error;

966

hp_slot_ptr->ops = &ibmphp_hotplug_slot_ops;

967

968

// end of registering ibm slot with hotplug core

969

970

list_add (& ((struct slot *)(hp_slot_ptr->private))->ibm_slot_list, &ibmphp_slot_head);

971

}

972

973

print_bus_info ();

974

list_add (&hpc_ptr->ebda_hpc_list, &ebda_hpc_head );

975

976

} /* each hpc */

977

978

list_for_each_entry(tmp_slot, &ibmphp_slot_head, ibm_slot_list) {

979

snprintf(name, SLOT_NAME_SIZE, "%s", create_file_name(tmp_slot));

980

pci_hp_register(tmp_slot->hotplug_slot,

981

pci_find_bus(0, tmp_slot->bus), tmp_slot->device, name);

982

}

983

984

print_ebda_hpc ();

985

print_ibm_slot ();

986

return 0;

987

988

error:

989

kfree (hp_slot_ptr->private);

990

error_no_slot:

991

kfree (hp_slot_ptr->info);

992

error_no_hp_info:

993

kfree (hp_slot_ptr);

994

error_no_hp_slot:

995

free_ebda_hpc (hpc_ptr);

996

error_no_hpc:

997

iounmap (io_mem);

998

return rc;

999

}

1000

1001

1002

* map info (bus, devfun, start addr, end addr..) of i/o, memory,

1003

* pfm from the physical addr to a list of resource.

1004

1005

static int __init ebda_rsrc_rsrc (void)

1006

{

1007

u16 addr;

1008

short rsrc;

1009

u8 type, rsrc_type;

1010

struct ebda_pci_rsrc *rsrc_ptr;

1011

1012

addr = rsrc_list_ptr->phys_addr;

1013

debug ("now entering rsrc land\n");

1014

debug ("offset of rsrc: %x\n", rsrc_list_ptr->phys_addr);

1015

1016

for (rsrc = 0; rsrc < rsrc_list_ptr->num_entries; rsrc++) {

1017

type = readb (io_mem + addr);

1018

1019

addr += 1;

1020

rsrc_type = type & EBDA_RSRC_TYPE_MASK;

1021

1022

if (rsrc_type == EBDA_IO_RSRC_TYPE) {

1023

rsrc_ptr = alloc_ebda_pci_rsrc ();

1024

if (!rsrc_ptr) {

1025

iounmap (io_mem);

1026

return -ENOMEM;

1027

}

1028

rsrc_ptr->rsrc_type = type;

1029

1030

rsrc_ptr->bus_num = readb (io_mem + addr);

1031

rsrc_ptr->dev_fun = readb (io_mem + addr + 1);

1032

rsrc_ptr->start_addr = readw (io_mem + addr + 2);

1033

rsrc_ptr->end_addr = readw (io_mem + addr + 4);

1034

addr += 6;

1035

1036

debug ("rsrc from io type ----\n");

1037

debug ("rsrc type: %x bus#: %x dev_func: %x start addr: %x end addr: %x\n",

1038

rsrc_ptr->rsrc_type, rsrc_ptr->bus_num, rsrc_ptr->dev_fun, rsrc_ptr->start_addr, rsrc_ptr->end_addr);

1039

1040

list_add (&rsrc_ptr->ebda_pci_rsrc_list, &ibmphp_ebda_pci_rsrc_head);

1041

}

1042

1043

if (rsrc_type == EBDA_MEM_RSRC_TYPE || rsrc_type == EBDA_PFM_RSRC_TYPE) {

1044

rsrc_ptr = alloc_ebda_pci_rsrc ();

1045

if (!rsrc_ptr ) {

1046

iounmap (io_mem);

1047

return -ENOMEM;

1048

}

1049

rsrc_ptr->rsrc_type = type;

1050

1051

rsrc_ptr->bus_num = readb (io_mem + addr);

1052

rsrc_ptr->dev_fun = readb (io_mem + addr + 1);

1053

rsrc_ptr->start_addr = readl (io_mem + addr + 2);

1054

rsrc_ptr->end_addr = readl (io_mem + addr + 6);

1055

addr += 10;

1056

1057

debug ("rsrc from mem or pfm ---\n");

1058

debug ("rsrc type: %x bus#: %x dev_func: %x start addr: %x end addr: %x\n",

1059

rsrc_ptr->rsrc_type, rsrc_ptr->bus_num, rsrc_ptr->dev_fun, rsrc_ptr->start_addr, rsrc_ptr->end_addr);

1060

1061

list_add (&rsrc_ptr->ebda_pci_rsrc_list, &ibmphp_ebda_pci_rsrc_head);

1062

}

1063

}

1064

kfree (rsrc_list_ptr);

1065

rsrc_list_ptr = NULL;

1066

print_ebda_pci_rsrc ();

1067

return 0;

1068

}

1069

1070

u16 ibmphp_get_total_controllers (void)

1071

{

1072

return hpc_list_ptr->num_ctlrs;

1073

}

1074

1075

struct slot *ibmphp_get_slot_from_physical_num (u8 physical_num)

1076

{

1077

struct slot *slot;

1078

1079

list_for_each_entry(slot, &ibmphp_slot_head, ibm_slot_list) {

1080

if (slot->number == physical_num)

1081

return slot;

1082

}

1083

return NULL;

1084

}

1085

1086

/* To find:

1087

* - the smallest slot number

1088

* - the largest slot number

1089

* - the total number of the slots based on each bus

1090

* (if only one slot per bus slot_min = slot_max )

1091

1092

struct bus_info *ibmphp_find_same_bus_num (u32 num)

1093

{

1094

struct bus_info *ptr;

1095

1096

list_for_each_entry(ptr, &bus_info_head, bus_info_list) {

1097

if (ptr->busno == num)

1098

return ptr;

1099

}

1100

return NULL;

1101

}

1102

1103

/* Finding relative bus number, in order to map corresponding

1104

* bus register

1105

1106

int ibmphp_get_bus_index (u8 num)

1107

{

1108

struct bus_info *ptr;

1109

1110

list_for_each_entry(ptr, &bus_info_head, bus_info_list) {

1111

if (ptr->busno == num)

1112

return ptr->index;

1113

}

1114

return -ENODEV;

1115

}

1116

1117

void ibmphp_free_bus_info_queue (void)

1118

{

1119

struct bus_info *bus_info;

1120

struct list_head *list;

1121

struct list_head *next;

1122

1123

list_for_each_safe (list, next, &bus_info_head ) {

1124

bus_info = list_entry (list, struct bus_info, bus_info_list);

1125

kfree (bus_info);

1126

}

1127

}

1128

1129

void ibmphp_free_ebda_hpc_queue (void)

1130

{

1131

struct controller *controller = NULL;

1132

struct list_head *list;

1133

struct list_head *next;

1134

int pci_flag = 0;

1135

1136

list_for_each_safe (list, next, &ebda_hpc_head) {

1137

controller = list_entry (list, struct controller, ebda_hpc_list);

1138

if (controller->ctlr_type == 0)

1139

release_region (controller->u.isa_ctlr.io_start, (controller->u.isa_ctlr.io_end - controller->u.isa_ctlr.io_start + 1));

1140

else if ((controller->ctlr_type == 1) && (!pci_flag)) {

1141

++pci_flag;

1142

pci_unregister_driver (&ibmphp_driver);

1143

}

1144

free_ebda_hpc (controller);

1145

}

1146

}

1147

1148

void ibmphp_free_ebda_pci_rsrc_queue (void)

1149

{

1150

struct ebda_pci_rsrc *resource;

1151

struct list_head *list;

1152

struct list_head *next;

1153

1154

list_for_each_safe (list, next, &ibmphp_ebda_pci_rsrc_head) {

1155

resource = list_entry (list, struct ebda_pci_rsrc, ebda_pci_rsrc_list);

1156

kfree (resource);

1157

resource = NULL;

1158

}

1159

}

1160

1161

static struct pci_device_id id_table[] = {

1162

{

1163

.vendor = PCI_VENDOR_ID_IBM,

1164

.device = HPC_DEVICE_ID,

1165

.subvendor = PCI_VENDOR_ID_IBM,

1166

.subdevice = HPC_SUBSYSTEM_ID,

1167

.class = ((PCI_CLASS_SYSTEM_PCI_HOTPLUG << 8) | 0x00),

1168

}, {}

1169

};

1170

1171

MODULE_DEVICE_TABLE(pci, id_table);

1172

1173

static int ibmphp_probe (struct pci_dev *, const struct pci_device_id *);

1174

static struct pci_driver ibmphp_driver = {

1175

.name = "ibmphp",

1176

.id_table = id_table,

1177

.probe = ibmphp_probe,

1178

};

1179

1180

int ibmphp_register_pci (void)

1181

{

1182

struct controller *ctrl;

1183

int rc = 0;

1184

1185

list_for_each_entry(ctrl, &ebda_hpc_head, ebda_hpc_list) {

1186

if (ctrl->ctlr_type == 1) {

1187

rc = pci_register_driver(&ibmphp_driver);

1188

break;

1189

}

1190

}

1191

return rc;

1192

}

1193

static int ibmphp_probe (struct pci_dev * dev, const struct pci_device_id *ids)

1194

{

1195

struct controller *ctrl;

1196

1197

debug ("inside ibmphp_probe\n");

1198

1199

list_for_each_entry(ctrl, &ebda_hpc_head, ebda_hpc_list) {

1200

if (ctrl->ctlr_type == 1) {

1201

if ((dev->devfn == ctrl->u.pci_ctlr.dev_fun) && (dev->bus->number == ctrl->u.pci_ctlr.bus)) {

1202

ctrl->ctrl_dev = dev;

1203

debug ("found device!!!\n");

1204

debug ("dev->device = %x, dev->subsystem_device = %x\n", dev->device, dev->subsystem_device);

1205

return 0;

1206

}

1207

}

1208

}

1209

return -ENODEV;

1210

}

1211

Older »