সরাসরি পর্বে যান
পর্ব ২৬ · ৮৫-এর মধ্যে · মডিউল ৪

8259 PIC — interrupt priority, ICW আর OCW

8259 PIC — Interrupt Priority, ICW and OCW

Taught in Bangla, this lesson explains the 8259A programmable interrupt controller: the IRR, ISR and IMR registers and the priority resolver, the INTA sequence that delivers a CALL to the 8085 or a type byte to the 8086, and ICW1–ICW4 initialisation. Initialisation runs in the course's 8085 simulator and 8086 runner, with the 8259 itself as the author's Python model, which shows a missing EOI starving a lower line. It covers OCWs, rotation, special mask, poll and cascading.

এই পর্বে যা শিখবেন

  • 8259A-এর block, pin আর IRR, ISR, IMR-এর কাজ দিয়ে একটি interrupt-এর পুরো যাত্রা বলা
  • ICW1–ICW4 আর OCW1–OCW3-এর প্রতিটি বিট পড়া, আর যেকোনো নকশার জন্য byte বানানো
  • 8085 mode-এর CALL ঠিকানা আর 8086 mode-এর type হাতে হিসাব করা
  • Non-specific আর specific EOI, fully nested, rotation আর special mask mode কখন কোনটি, তা বোঝা
  • Master–slave cascade সাজানো, আর সাধারণ ভুল (EOI ভুলে যাওয়া, ভুল port) ধরতে পারা

১ · একটি INTR লাইন, অনেক যন্ত্র — কেন 8259

পর্ব ১৩-এ দেখেছেন, 8085-এর পাঁচটি interrupt pin-এর মধ্যে মাত্র একটি, INTR, বাইরের যন্ত্রকে নিজের ঠিকানা বেছে নেওয়ার সুযোগ দেয়। পর্ব ২০-এ দেখেছেন, 8086-এর ২৫৬টি type থাকলেও hardware-এর জন্য সাধারণ pin সেই একটিই, INTR. অথচ একটি বাস্তব যন্ত্রে interrupt চায় অনেকে: keyboard, timer, serial port, sensor-এর সতর্কসংকেত। একটি লাইনে আটজনকে বসাতে হলে কাউকে ঠিক করতে হবে কে আগে কথা বলবে, আর CPU-কে জানাতে হবে কার জন্য ডাকা হয়েছে।

তিনটি পথ আছে। প্রথম, polling: সব যন্ত্রের অনুরোধ OR করে INTR-এ দেওয়া, আর ISR-এর ভেতরে একে একে প্রত্যেকের status পড়ে খোঁজা কে ডেকেছে। সহজ, কিন্তু খোঁজায় সময় যায়। দ্বিতীয়, daisy chain: acknowledge সংকেত যন্ত্র থেকে যন্ত্রে শিকলের মতো যায়, প্রথম অনুরোধকারী সংকেতটি ধরে নিজের vector দেয়; অগ্রাধিকার তারের অবস্থানে বাঁধা। তৃতীয়, একটি programmable interrupt controller (PIC): আলাদা একটি chip, যা অনুরোধ জমা রাখে, mask আর অগ্রাধিকার software থেকে বদলাতে দেয়, আর acknowledge-এর সময় ঠিক vector দেয়। Intel-এর সেই chip হলো 8259A, এই পর্বের বিষয়।

উপমা — ডাক্তারের চেম্বারের সহকারী: এক ডাক্তার, বাইরে অনেক রোগী। দরজায় বসা সহকারীর হাতে তিনটি খাতা। প্রথমটিতে লেখা কে কে এসে বসে আছেন (অপেক্ষার খাতা = IRR). দ্বিতীয়টিতে লেখা ডাক্তার এখন কার সঙ্গে কথা বলছেন (চলতি খাতা = ISR). তৃতীয়টিতে লেখা “আজ এঁদের ডাকা হবে না” (নিষেধের খাতা = IMR). সহকারী নিজে নিয়ম মেনে ঠিক করেন কে পরে ঢুকবেন: জরুরি রোগী আগে, তবে চলতি রোগীর চেয়ে কম জরুরি কাউকে মাঝপথে ঢোকানো যাবে না। রোগী বেরিয়ে গেলে ডাক্তার ঘণ্টা বাজিয়ে জানান “শেষ”; সেই ঘণ্টাই EOI. ঘণ্টা না বাজলে সহকারী ভাবেন আগের রোগী এখনো ভেতরে।

বাজারঘরের দোকানে এই পর্বে একটি 8086 বোর্ড কল্পনা করুন, যেখানে তিনটি যন্ত্র interrupt চায়: smart scale-এর tare বোতাম (চাপলে তখনকার ওজন শূন্য ধরা হয়), cold-storage monitor-এর alarm (৩ বার পরপর 8.00 °C-এর ওপরে বা 0.00 °C-এর নিচে পড়লে), আর একটি UART receive (serial লাইনে একটি byte এসেছে, পরের byte আসার আগেই পড়তে হবে). Reference lab-এর README-এর সংখ্যাগুলো এখানেও একই: তাপমাত্রা প্রতি 1 s-এ পড়া, telemetry প্রতি 10 s-এ। কোন লাইনে কোনটি বসবে, তা অংশ ২-এ ঠিক করব; উত্তরটি শুনে হয়তো একটু অবাক হবেন।

লেখার নিয়ম আগের পর্বগুলোর মতো: hex Intel-এর ধরনে, শেষে H (20H, 0F8H), আর binary শুধু টেবিলে বা register-এর ছাপে (00000110). কোডের ভেতরে 8085-এ Intel ধাঁচ (0F6H), 8086-এ NASM-এর ছোট হাতের h. Interrupt-এর CPU-র দিক, অর্থাৎ INTR, INTA, IVT আর type, পর্ব ১৩ আর ২০-এর বিষয়; এখানে শুধু মনে করিয়ে দেওয়া হবে। Interrupt controller কেন দরকার, তার নকশার তত্ত্ব Computer Architecture পর্ব ৫২-এ।

২ · 8259A-এর ভেতরে — IRR, ISR, IMR আর priority resolver

Intel-এর 8259A datasheet (order number 231468-003, ডিসেম্বর ১৯৮৮) chip-টিকে এভাবে পরিচয় দেয়: আটটি vectored priority interrupt সামলায়, বাড়তি circuit ছাড়াই cascade করে ৬৪টি পর্যন্ত, 28-pin DIP, একটি +5 V supply, আর কোনো clock লাগে না। নিচের ছবিতে datasheet-এর block diagram, বাজারঘরের তিনটি লাইনসহ।

ছবি ২৬.১ — 8259A-এর ভেতরের block আর বাজারঘরের তিনটি IR লাইন

ওপরে CPU, মাঝে সিদ্ধান্তের তিন block আর IMR, নিচে bus-এর দিকের তিন block (Intel datasheet-এর Figure 1 অনুসারে, সরল করে)

8259A-এর block diagram CPU (8085 বা 8086) INTA̅ INT → INTR Control logic ISR সেবা চলছে Priority resolver IRR অনুরোধ IR0 UART IR1 alarm IR2 tare IR3–IR7 IMR · mask (OCW1) internal bus Data bus buffer Read/write logic Cascade buffer D7–D0 RD̅ WR̅ A0 CS̅ CAS0–2 SP̅/EN̅ 28 pin · +5 V · clock লাগে না শুরুতে IR0 উঁচু, IR7 নিচু
ছবি ২৬.১ — তিনটি register-ই ৮ বিটের, বিট n মানে IRn. IMR থেকে তীর IRR-এর দিকে নয়, priority resolver-এর দিকে: mask অনুরোধকে মোছে না, শুধু আটকে রাখে (অনুশীলন ১-এর run-এ IR4 তা-ই দেখায়).

Block-গুলোর কাজ, datasheet-এর ভাষা অনুসারে:

  • IRR (interrupt request register): কোন IR লাইন অনুরোধ করেছে কিন্তু এখনো acknowledge পায়নি। Datasheet স্পষ্ট বলে, IRR-কে IMR প্রভাবিত করে না; mask করা লাইনের অনুরোধও এখানে জমে থাকে, যা pending interrupt-এর সংজ্ঞা।
  • ISR (in-service register): কোন level-এর সেবা চলছে। একটি সতর্কতা: এখানে ISR মানে register, আর আগের পর্বগুলোর ISR মানে interrupt service routine, অর্থাৎ ফাংশন। এই পর্বে register বোঝাতে সবসময় “ISR register” বা বিটের ছাপ (ISR=00000100) লেখা হবে।
  • IMR (interrupt mask register): বিট = 1 হলে সেই লাইন আটকানো। Datasheet-এর কথায়, উঁচু অগ্রাধিকারের লাইন mask করলে নিচুগুলোর ওপর কোনো প্রভাব পড়ে না।
  • Priority resolver: IRR-এর অনুরোধগুলোর মধ্যে সবচেয়ে উঁচুটি বাছে, আর INTA̅-এর সময় সেটিকে ISR-এ বসায়।
  • Control logic: INT pin উঁচু করে CPU-কে ডাকে, INTA̅ pulse গোনে, data bus-এ vector-এর byte দেয়।
  • Data bus buffer আর read/write logic: CPU-র OUT থেকে command word নেয়, IN-এ status দেয়। A0 pin বলে দেয় কোন word; এর পুরো গল্প অংশ ৪-এ।
  • Cascade buffer/comparator: CAS0–CAS2 আর SP̅/EN̅, একাধিক 8259 জোড়ার জন্য (অংশ ৭).
Pinনামকাজ
1, 2, 3CS̅, WR̅, RD̅Chip select আর লেখা-পড়া; INTA̅ CS̅-এর ওপর নির্ভর করে না
4–11D7–D0দুই দিকের data bus: command, status আর vector
12, 13, 15CAS0–CAS2Master-এ output, slave-এ input
14, 28GND, VCC0 V আর +5 V
16SP̅/EN̅Buffered mode-এ buffer চালু করার output; না হলে input: 1 = master, 0 = slave
17INTCPU-র INTR-এ যায়
18–25IR0–IR7যন্ত্রের অনুরোধ
26INTA̅CPU-র acknowledge pulse
27A0কোন command word; 8086-এ সাধারণত CPU-র A1-এ যুক্ত

বাজারঘরের লাইন বণ্টন — “গুরুত্ব” নয়, “কতক্ষণ অপেক্ষা সয়”

প্রথম চিন্তায় মনে হয় alarm সবচেয়ে গুরুত্বপূর্ণ, তাই IR0. কিন্তু interrupt priority ঠিক হয় কে কত কম সময় অপেক্ষা সইতে পারে তা দিয়ে। UART-এ 9600 baud-এ একটি byte-এর ফ্রেম (১০ বিট) প্রায় 1.04 ms; পরের byte আসার আগে আগেরটি না পড়লে সেটি হারায়। Cold-room-এর পড়া আসে প্রতি 1 s-এ, আর alarm চালু হতেই লাগে তিনটি পড়া, অর্থাৎ কয়েক সেকেন্ড; কয়েক মিলিসেকেন্ড দেরিতে কোনো ক্ষতি নেই। Tare বোতাম মানুষ চাপে, আর মানুষের কাছে 50 ms-ও তাৎক্ষণিক। তাই বণ্টন: IR0 = UART receive, IR1 = cold-room alarm, IR2 = tare বোতাম, বাকি পাঁচটি mask করা। পরীক্ষায় এই যুক্তিটি লিখতে পারলে নম্বর পাওয়া যায়; একই ধারণা পরে RTOS-এর rate monotonic নিয়মে ফিরে আসবে (পর্ব ৫৬).

Bus-এর দিকে 8259-এর মাত্র দুটি ঠিকানা লাগে, A0 = 0 আর A0 = 1. এই পর্বের 8085 নকশায় 8259 বসেছে port 20H (A0 = 0) আর 21H (A0 = 1)-এ। 8086 নকশায় 8259-এর data লাইন D7–D0-এ, অর্থাৎ শুধু জোড় ঠিকানার byte-এ; তাই 8259-এর A0 pin যায় CPU-র A1-এ (datasheet-এও তা-ই বলা), আর port দুটি 0F0H (A0 = 0) আর 0F2H (A0 = 1). Chip select আসে A7–A2 = 111100-এর decoder থেকে। Port আর decoder-এর নকশা পর্ব ২৩-এ, জোড়-বিজোড় byte-এর কথা পর্ব ২২-এ।

৩ · একটি interrupt-এর যাত্রা — INTA, CALL আর type

Datasheet-এর “Interrupt Sequence” অংশ ধাপগুলো এভাবে দেয়। (১) এক বা একাধিক IR লাইন উঁচু হয়, IRR-এর বিট বসে। (২) 8259 অনুরোধগুলো যাচাই করে, দরকার হলে INT উঁচু করে। (৩) CPU চলতি নির্দেশ শেষ করে, IE বা IF চালু থাকলে একটি INTA̅ pulse দেয় (interrupt acknowledge). (৪) প্রথম INTA̅-তে সবচেয়ে উঁচু অনুরোধের ISR বিট বসে আর IRR বিট মোছে। এরপর CPU-ভেদে পথ আলাদা।

ধাপ8085 mode (µPM = 0)8086 mode (µPM = 1)
প্রথম INTA̅ISR বিট বসে; data bus-এ CALL-এর opcode CDH (11001101)ISR বিট বসে; 8259 data bus চালায় না
দ্বিতীয় INTA̅ঠিকানার নিচু byteType byte: ICW2-এর T7–T3 + IR-এর ৩ বিট
তৃতীয় INTA̅ঠিকানার উঁচু byte (= ICW2)নেই
CPU যা করেPC stack-এ রেখে সেই ঠিকানায় যায়, যেন CALLFLAGS, CS, IP রেখে IVT-র type × 4 থেকে নতুন CS:IP (পর্ব ২০)
AEOI হলে ISR বিট মোছেতৃতীয় INTA̅-এর শেষেদ্বিতীয় INTA̅-এর শেষে

8085 mode-এ নিচু byte কীভাবে বানানো হয়? ICW1-এর ADI বিট (call address interval) ঠিক করে প্রতিটি IR-এর জন্য কত byte-এর ঘর। Interval 4 হলে নিচু byte = A7 A6 A5 (ICW1 থেকে) + IR-এর ৩ বিট + 00; interval 8 হলে A7 A6 + IR-এর ৩ বিট + 000. ফলে আটটি ঘর মিলে একটি 32 বা 64 byte-এর “পাতা”, যার প্রতিটি ঘরে সাধারণত একটি JMP থাকে আসল ISR-এ। 8086 mode-এ ICW1-এর A7–A5 আর ADI উপেক্ষিত; type = ICW2-এর ওপরের পাঁচ বিট + IR নম্বর। এই পর্বের নকশায় ICW2 = 40H, তাই IR0 → 40H, IR1 → 41H, IR2 → 42H, আর type 41H-এর vector IVT-র 41H × 4 = 00104H-এ।

আরেকটি নিয়ম datasheet-এ ছোট করে লেখা, কিন্তু বাস্তবে বড়: edge বা level দুই mode-এই IR লাইন প্রথম INTA̅-এর পতন পর্যন্ত উঁচু থাকতে হয়। তার আগে নেমে গেলে 8259 IR7-এর vector দেয়, কিন্তু ISR-এর বিট বসায় না। এই “default IR7” হলো একটি spurious interrupt; noise ধরার জন্য IR7-এর ISR-এ ISR register পড়ে দেখা হয় বিট 7 বসেছে কি না।

নিচের Python মডেল (pic8259.py, পাতার সঙ্গে দেওয়া সহায়ক file) datasheet-এর নিয়মগুলো লেখে: IRR, ISR, IMR, resolver, INTA, EOI, rotation আর cascade. লেখকের lab-এ ১৮টি test-এ যাচাই করা, যার একটি datasheet-এর নিজের rotation উদাহরণ। Reference lab-এ 8259-এর কোনো emulator নেই, তাই chip-এর আচরণ এই পর্বে সবখানে এই মডেল থেকে; CPU-র কোড আর byte এসেছে সত্যিকারের run থেকে।

# দুটি অনুরোধ একসঙ্গে: priority resolver কাকে আগে দেয়, আর data bus-এ কী যায়
from pic8259 import PIC                  # পাতার সহায়ক মডেল pic8259.py

def setup(mode):
    p = PIC()
    if mode == "8086":                   # ICW1 13H, ICW2 40H, ICW4 01H, OCW1 F8H
        words = [(0, 0x13), (1, 0x40), (1, 0x01), (1, 0xF8)]
    else:                                # ICW1 F6H, ICW2 20H, OCW1 F8H
        words = [(0, 0xF6), (1, 0x20), (1, 0xF8)]
    for a0, v in words:
        p.write(a0, v)
    return p

name = {0: "UART", 1: "alarm", 2: "tare"}
for mode in ("8086", "8085"):
    p = setup(mode)
    p.request(2); p.request(1)           # tare আর alarm একই মুহূর্তে
    print(f"--- {mode} mode, শুরু: {p.show()}")
    while p.int_pin():
        data, n = p.inta()
        bus = " ".join(f"{x:02X}" for x in data)
        print(f"IR{n} {name[n]:5} bus: {bus:9} {p.show()}")
        p.write(0, 0x20)                 # ISR-এর শেষে non-specific EOI

print("--- IR1 উঠে প্রথম INTA-এর আগেই নেমে গেল")
p = setup("8086")
p.request(1); p.drop(1)
data, n = p.inta()
print(f"bus: {data[0]:02X}  -> IR{n} (default), ISR={p.isr:08b}")

আসল আউটপুট (ব্রাউজারের Python):

--- 8086 mode, শুরু: IRR=00000110 ISR=00000000 IMR=11111000
IR1 alarm bus: 41        IRR=00000100 ISR=00000010 IMR=11111000
IR2 tare  bus: 42        IRR=00000000 ISR=00000100 IMR=11111000
--- 8085 mode, শুরু: IRR=00000110 ISR=00000000 IMR=11111000
IR1 alarm bus: CD E4 20  IRR=00000100 ISR=00000010 IMR=11111000
IR2 tare  bus: CD E8 20  IRR=00000000 ISR=00000100 IMR=11111000
--- IR1 উঠে প্রথম INTA-এর আগেই নেমে গেল
bus: 47  -> IR7 (default), ISR=00000000

দুই mode-এই alarm (IR1) আগে, tare (IR2) পরে, কারণ শুরুর নিয়মে ছোট নম্বর উঁচু। 8086 mode-এ bus-এ শুধু type: 41, তারপর 42. 8085 mode-এ পুরো CALL: CD E4 20 মানে CALL 20E4H, কারণ ICW1 = F6H-এর A7–A5 = 111, interval 4, তাই নিচু byte = 111 001 00 = E4H. লক্ষ করুন, প্রথম সেবার সময় IRR-এ IR2 বসে আছে, কিন্তু resolver তাকে ছাড়েনি: ISR-এ উঁচু IR1 থাকায় EOI না আসা পর্যন্ত সে অপেক্ষা করেছে। শেষ লাইনে লাইন আগেভাগে নেমে যাওয়ায় bus-এ 47 (IR7-এর type) এসেছে, অথচ ISR register শূন্য: spurious interrupt চেনার উপায় এটিই।

8259-এর অবস্থা (IMR = 11111000)
ঘটনা
IRR
ISR
INT
Data bus
  1. দুটি অনুরোধ একসঙ্গে। Cold room-এর তৃতীয় গরম পড়া আর tare বোতাম একই মুহূর্তে। IRR-এর বিট 1 আর 2 বসেছে (00000110). দুটিই IMR-এ খোলা, ISR ফাঁকা, তাই INT = 1.
  2. প্রথম INTA̅. CPU চলতি নির্দেশ শেষ করে, IF = 1 দেখে INTA̅ দিল। Resolver উঁচুটি বাছল, IR1: ISR = 00000010, IRR থেকে বিট 1 মুছল। 8086 mode-এ এই pulse-এ 8259 data bus-এ কিছু দেয় না।
  3. দ্বিতীয় INTA̅. 8259 bus-এ রাখল type 41H = ICW2-এর 01000 + IR-এর 001. CPU এবার পর্ব ২০-এর পথে: FLAGS, CS, IP stack-এ, আর 00104H-এর vector থেকে alarm-এর ISR.
  4. Alarm-এর ISR চলছে। IRR-এ IR2 এখনো বসে আছে, কিন্তু INT = 0: ISR-এ উঁচু IR1 থাকায় সমান বা নিচু কাউকে resolver ছাড়বে না। এটিই fully nested mode.
  5. EOI. ISR শেষ হওয়ার ঠিক আগে mov al, 20h আর out 0F0h, al: non-specific EOI. ISR-এর সবচেয়ে উঁচু বিট (IR1) মুছল, ISR = 00000000. এখন IR2-কে আটকানোর কেউ নেই, INT আবার 1.
  6. আবার দুই INTA̅. ISR থেকে IRET-এর পরে IF = 1, তাই CPU পরের নির্দেশের সীমাতেই নতুন INT নেয়। IR2: ISR = 00000100, IRR ফাঁকা, bus-এ 42H.
  7. Tare-এর EOI. Tare-এর ISR-ও শেষে 20H দেয়; সব register শূন্য, INT = 0. দুটি অনুরোধই সেবা পেল, অগ্রাধিকারের ক্রমে, কেউ হারায়নি। Python মডেলের লাইনগুলোর সঙ্গে প্রতিটি ধাপ মিলিয়ে দেখুন।

৪ · ICW1–ICW4 — শুরুর প্রোগ্রামিং

8259 চালু হওয়ার পরে কোনো কাজের আগে তাকে দুই থেকে চারটি initialization command word (ICW) দিতে হয়, ঠিক এই ক্রমে। A0 = 0-তে লেখা কোনো byte-এর বিট D4 = 1 হলে 8259 তাকে ICW1 ধরে, আর নতুন করে শুরুর ক্রম আরম্ভ করে। Datasheet অনুযায়ী ICW1 তখন নিজে থেকেই কয়েকটি কাজ করে: edge ধরার circuit reset, IMR মুছে 00H, IR7-কে সবচেয়ে নিচু অগ্রাধিকার, special mask mode বন্ধ, পরের status পড়া = IRR, আর IC4 = 0 হলে ICW4-এর সব বিট শূন্য ধরা। এরপর A0 = 1-এ ICW2, দরকার হলে ICW3, দরকার হলে ICW4.

WordA0D7D6D5D4D3D2D1D0
ICW10A7A6A51LTIMADISNGLIC4
ICW21A15/T7A14/T6A13/T5A12/T4A11/T3A10A9A8
ICW3 master1S7S6S5S4S3S2S1S0
ICW3 slave100000ID2ID1ID0
ICW41000SFNMBUFM/SAEOIµPM
  • ICW1: LTIM = 1 level-triggered, 0 edge-triggered; ADI = 1 হলে CALL-এর ঘর ৪ byte, 0 হলে ৮ byte (শুধু 8085); SNGL = 1 মানে একটিই 8259 (ICW3 আসবে না); IC4 = 1 মানে ICW4 আসবে। A7–A5 শুধু 8085 mode-এ।
  • ICW2: 8085 mode-এ CALL ঠিকানার উঁচু byte (A15–A8); 8086 mode-এ type-এর ওপরের পাঁচ বিট, নিচের তিন বিট 8259 নিজে বসায়।
  • ICW3: শুধু SNGL = 0 হলে। Master-এ যে IR-এ slave আছে তার বিট = 1; slave-এ নিজের ID, অর্থাৎ master-এর কোন IR-এ সে বসেছে।
  • ICW4: µPM = 1 মানে 8086/8088 mode; AEOI = 1 হলে নিজে থেকে EOI; BUF আর M/S buffered mode-এর জন্য; SFNM = 1 special fully nested mode (অংশ ৭). 8086-এ ICW4 বাধ্যতামূলক, কারণ IC4 = 0 হলে µPM = 0 ধরা হয়, অর্থাৎ 8085 mode.

নিচের ছোট program বিটগুলো থেকে byte বানায় আর উল্টো দিকে পড়ে। তিনটি নকশা: বাজারঘরের 8086 বোর্ড, অনুশীলনের একটি level-triggered AEOI নকশা, আর 8085 বোর্ড।

# ICW-এর byte বানানো আর পড়া (Intel 8259A datasheet-এর বিট-বিন্যাস)
def icw1(level=False, single=True, ic4=True, interval4=False, a7_5=0):
    return a7_5 << 5 | 0x10 | level << 3 | interval4 << 2 | single << 1 | ic4

def icw4(x86=True, aeoi=False, buf=None, sfnm=False):
    b = 0 if buf is None else 0x08 | (buf == "master") << 2
    return sfnm << 4 | b | aeoi << 1 | x86

def read1(v):
    return (f"ICW1 {v:02X}H = {v:08b}: " + ("level" if v & 8 else "edge")
            + (", single" if v & 2 else ", cascade+ICW3")
            + (", ICW4 আসবে" if v & 1 else ", ICW4 নেই")
            + ("" if v & 1 else f", interval {4 if v & 4 else 8}"))

def read4(v):
    buf = ("non-buffered", "non-buffered", "buffered slave", "buffered master")[v >> 2 & 3]
    return (f"ICW4 {v:02X}H = {v:08b}: " + ("8086" if v & 1 else "8085")
            + (", AEOI" if v & 2 else ", normal EOI") + f", {buf}"
            + (", SFNM" if v & 16 else ""))

designs = {
    "বাজারঘর 8086": (icw1(), 0x40, icw4()),
    "level + AEOI": (icw1(level=True), 0x50, icw4(aeoi=True)),
    "8085, 20E0H":  (icw1(ic4=False, interval4=True, a7_5=0b111), 0x20, None),
}
for name, (w1, w2, w4) in designs.items():
    seq = " ".join(f"{w:02X}H" for w in (w1, w2, w4) if w is not None)
    print(f"{name:13} -> {seq}")
    print("   " + read1(w1))
    print(f"   ICW2 {w2:02X}H: " + (f"IR0..IR7 = type {w2:02X}H..{w2 | 7:02X}H"
                                     if w4 else f"ঠিকানার উঁচু byte {w2:02X}H"))
    if w4 is not None:
        print("   " + read4(w4))

আসল আউটপুট (ব্রাউজারের Python):

বাজারঘর 8086  -> 13H 40H 01H
   ICW1 13H = 00010011: edge, single, ICW4 আসবে
   ICW2 40H: IR0..IR7 = type 40H..47H
   ICW4 01H = 00000001: 8086, normal EOI, non-buffered
level + AEOI  -> 1BH 50H 03H
   ICW1 1BH = 00011011: level, single, ICW4 আসবে
   ICW2 50H: IR0..IR7 = type 50H..57H
   ICW4 03H = 00000011: 8086, AEOI, non-buffered
8085, 20E0H   -> F6H 20H
   ICW1 F6H = 11110110: edge, single, ICW4 নেই, interval 4
   ICW2 20H: ঠিকানার উঁচু byte 20H

8086-এর বাজারঘর নকশার ক্রম 13H 40H 01H: তিনটি word, কারণ SNGL = 1 বলে ICW3 নেই, আর IC4 = 1 বলে ICW4 আছে। 8085 নকশায় মাত্র দুটি: F6H-এ IC4 = 0, তাই 8259 ICW4-এর সব বিট শূন্য ধরে, যা ঠিক 8085 mode, normal EOI আর non-buffered. ICW1-এর বাইরের D4 = 1 বিটটির দিকে খেয়াল রাখুন: তিনটি ICW1-এই তা আছে (13H, 1BH, F6H), আর OCW2/OCW3-এ সেটি সবসময় 0. এভাবেই একই A0 = 0 ঠিকানায় 8259 তিন রকম word আলাদা করে চেনে।

CPU যা লেখে, 8259 যা বোঝে
নির্দেশ
A0 · binary
8259 বোঝে
এরপর আশা
IMR
  1. আগে CPU-র দরজা বন্ধ। শুরুর মাঝপথে কোনো interrupt এলে অর্ধেক-প্রোগ্রাম করা 8259 ভুল type দিতে পারে, তাই cli. চালু হওয়ার পরে 8259-এর IMR-এ কী আছে, তা জানা নেই।
  2. ICW1 = 13H, A0 = 0. D4 = 1, তাই এটি ICW1. LTIM = 0 (edge), ADI = 0 (8086-এ অর্থহীন), SNGL = 1, IC4 = 1. সঙ্গে সঙ্গে IMR = 00H, IR7 সবচেয়ে নিচু। এখন 8259 অপেক্ষা করছে ICW2 আর ICW4-এর।
  3. ICW2 = 40H, A0 = 1. ওপরের পাঁচ বিট 01000, তাই IR0–IR7 যাবে type 40H–47H-এ। Type 0–31 Intel-এর সংরক্ষিত (পর্ব ২০), তাই 40H নিরাপদ পছন্দ।
  4. ICW3 লেখা হয় না। SNGL = 1 মানে এই বোর্ডে একটিই 8259; ভুল করে এখানে কিছু লিখলে 8259 সেটিকে ICW4 ধরবে।
  5. ICW4 = 01H, A0 = 1. µPM = 1 (8086 mode), AEOI = 0, BUF = 0, SFNM = 0. শুরুর ক্রম শেষ; এখন থেকে A0 = 1-এ লেখা মানে OCW1.
  6. OCW1 = F8H. IMR = 11111000: IR0 (UART), IR1 (alarm), IR2 (tare) খোলা, IR3–IR7 বন্ধ। ব্যবহার না হওয়া লাইন খোলা রাখলে ভাসমান pin-এর noise থেকে অকারণ interrupt আসতে পারে।
  7. দরজা খোলা। IVT-র 00100H–0010BH-এ তিনটি vector লেখার পরে sti. এখন থেকে যেকোনো IR উঠলেই অংশ ৩-এর যাত্রা শুরু হবে।

সত্যিকারের run — 8085 আর 8086

প্রথমে 8085. নিচের program reference lab-এর sim8085.py-তে assemble করে চালানো (Python 3.13.5; লেখকের lab-এ, কোনো পরিবর্তন ছাড়া). 20E0H থেকে CALL-এর টেবিল, IR2-এর ঘর 20E8H-এ tare-এর ISR-এ লাফ।

; pic85.asm - 8259A in 8085 mode at ports 20H (A0=0) and 21H (A0=1)
        ORG 2000H
START:  DI
        MVI A,0F6H      ; ICW1: A7-A5=111, edge, interval 4, single, no ICW4
        OUT 20H
        MVI A,20H       ; ICW2: A15-A8 = 20H -> CALL table at 20E0H
        OUT 21H
        MVI A,0F8H      ; OCW1: IR0-IR2 open
        OUT 21H
        EI
        HLT             ; wait for an interrupt
; ISR for IR2 (tare button); the 8259 sends CALL 20E8H
TARE:   PUSH PSW
        MVI A,01H
        STA 2050H       ; flag for the main program
        MVI A,20H       ; OCW2: non-specific EOI
        OUT 20H
        POP PSW
        EI
        RET
        ORG 20E0H       ; CALL table, 4 bytes per IR
        JMP 0000H       ; IR0 (UART receive ISR would go here)
        NOP
        JMP 0000H       ; IR1 (cold-room alarm ISR)
        NOP
        JMP TARE        ; IR2 at 20E8H
        END START
$ python -B sim8085.py run pic85.asm
A=F8 B=00 C=00 D=00 E=00 H=00 L=00 SP=0000 PC=200F
Flags: S=0 Z=0 AC=0 P=0 CY=0   (F=00H)
OUT port 20H <- F6H  (at T=21)
OUT port 21H <- 20H  (at T=38)
OUT port 21H <- F8H  (at T=55)
Instructions: 9   T-states: 64

OUT-এর লগে ঠিক তিনটি byte, ঠিক ক্রমে: ICW1 F6H port 20H-এ (A0 = 0), ICW2 20H আর OCW1 F8H port 21H-এ (A0 = 1). প্রতিটি MVI 7 T আর OUT 10 T (Spec decision 2), তাই প্রথম OUT T = 4 + 7 + 10 = 21-এ, পরেরগুলো 17 T পরপর। asm-এর listing-এ টেবিলের ঘর 20E8 C3 0F 20: JMP 200FH, অর্থাৎ TARE. HLT-এ run থেমেছে, কারণ simulator-এর INTR শুধু এক byte-এর RST n নিতে পারে (Spec decision 7); 8259-এর তিন byte-এর CALL সেখানে চালানো যায় না, তাই সেই অংশ ওপরের Python মডেল দেখিয়েছে (CD E8 20). ISR-এর শেষে EI লাগে, কারণ INTR acknowledge 8085-এর IE মুছে দেয় (Spec decision 7, পর্ব ১৩).

এবার 8086. Program-টি NASM 3.02 (BSD-2-Clause) দিয়ে assemble করে reference lab-এর run8086.py-এর CPU-তে চালানো, Unicorn 2.1.4-এ (binding BSD, engine GPLv2). Lab-এর runner-এ I/O port নেই, তাই লেখক নিজের lab-এ একটি ছোট মোড়ক (run8259.py) লিখেছেন: reference-এর run8086.py অপরিবর্তিত import করে, OUT/IN F0H আর F2H-কে Python মডেলে পাঠায়, আর মডেলের INT = 1 ও IF = 1 হলে নির্দেশের সীমায় পর্ব ২০-এর নিয়মে type নিয়ে IVT ধরে লাফ দেয় (STI-এর পরের এক নির্দেশ বাদে). অর্থাৎ CPU আর কোড সত্যিকারের, 8259 মডেল।

; pic86.asm - one 8259A in 8086 mode: ICWs, mask, 3 ISRs with EOI
        org 100h
PIC0    equ 0F0h                ; 8259 A0 = 0 (A0 pin <- CPU A1)
PIC1    equ 0F2h                ; 8259 A0 = 1
        cli
        mov al, 13h             ; ICW1: edge, single, ICW4 needed
        out PIC0, al
        mov al, 40h             ; ICW2: IR0 -> type 40h
        out PIC1, al
        mov al, 01h             ; ICW4: 8086 mode, normal EOI
        out PIC1, al
        mov al, 0F8h            ; OCW1: IR0-IR2 open, IR3-IR7 masked
        out PIC1, al
        xor ax, ax
        mov es, ax
        mov di, 40h*4           ; IVT entries of types 40h-42h
        mov si, isrs
        mov cx, 3
vec:    lodsw
        stosw                   ; IP
        mov ax, cs
        stosw                   ; CS
        loop vec
        sti
idle:   cmp byte [count], 3     ; main loop: wait for 3 interrupts
        jb idle
        mov ax, 4C00h
        int 21h
isr0:   push ax                 ; IR0: UART receive
        mov al, 'U'
        jmp short serve
isr1:   push ax                 ; IR1: cold-room alarm
        mov al, 'A'
        jmp short serve
isr2:   push ax                 ; IR2: tare button
        mov al, 'T'
serve:  push dx
        mov dl, al
        mov ah, 02h
        int 21h                 ; print the letter
        mov al, 20h             ; OCW2: non-specific EOI
        out PIC0, al
        inc byte [count]
        pop dx
        pop ax
        iret
isrs:   dw isr0, isr1, isr2
count:  db 0
$ python -B run8259.py pic86.asm --ir 40:2,1,0
8259| OUT F0h <- 13h  ICW1                     IRR=00000000 ISR=00000000 IMR=00000000
8259| OUT F2h <- 40h  ICW2                     IRR=00000000 ISR=00000000 IMR=00000000
8259| OUT F2h <- 01h  ICW4                     IRR=00000000 ISR=00000000 IMR=00000000
8259| OUT F2h <- F8h  OCW1 (IMR)               IRR=00000000 ISR=00000000 IMR=11111000
8259| step 40: IR2,1,0 raised  IRR=00000111 ISR=00000000 IMR=11111000
8259| INTR -> 2 x INTA, IR0, type 40h   IRR=00000110 ISR=00000001 IMR=11111000
U
8259| OUT F0h <- 20h  OCW2 non-specific EOI    IRR=00000110 ISR=00000000 IMR=11111000
8259| INTR -> 2 x INTA, IR1, type 41h   IRR=00000100 ISR=00000010 IMR=11111000
A
8259| OUT F0h <- 20h  OCW2 non-specific EOI    IRR=00000100 ISR=00000000 IMR=11111000
8259| INTR -> 2 x INTA, IR2, type 42h   IRR=00000000 ISR=00000100 IMR=11111000
T
8259| OUT F0h <- 20h  OCW2 non-specific EOI    IRR=00000000 ISR=00000000 IMR=11111000
[exit code 0 via INT 21h/4Ch, 82 instructions]

৪০তম নির্দেশে তিনটি লাইন একসঙ্গে উঠেছে (IRR = 00000111). সেবা হয়েছে U, A, T ক্রমে: IR0, IR1, IR2, প্রতিবার দুই INTA̅-এ type 40H, 41H, 42H. প্রতিটি ISR-এর out 0F0h, al (20H) লগে “non-specific EOI” হয়ে এসেছে আর ISR-এর বিট মুছেছে; তার পরেই পরের অনুরোধ INT পেয়েছে। পুরো run মাত্র ৮২টি নির্দেশ, আর DOS-এর INT 21h/4Ch দিয়ে পরিষ্কার শেষ।

৫ · OCW আর EOI — চলার সময়ের নির্দেশ

শুরুর পরে যেকোনো সময় তিনটি operation command word (OCW) লেখা যায়। কোনটি কোন word, তা A0 আর D4–D3 থেকে বোঝা যায়:

WordA0D7D6D5D4D3D2D1D0
OCW11M7M6M5M4M3M2M1M0
OCW20RSLEOI00L2L1L0
OCW300ESMMSMM01PRRRIS

OCW1 সরাসরি IMR: M = 1 মানে বন্ধ (interrupt masking). OCW3-এর RR = 1 হলে পরের IN-এ RIS = 0-তে IRR, RIS = 1-এ ISR register পড়া যায় (0AH আর 0BH); IMR পড়তে কোনো OCW3 লাগে না, A0 = 1-এ IN করলেই হয়। P = 1 মানে poll (অংশ ৬), ESMM আর SMM দিয়ে special mask mode. OCW2-ই সবচেয়ে ব্যবহৃত, কারণ EOI তার মাধ্যমে যায়। R, SL, EOI তিন বিটের আটটি মানে:

R SL EOIByte (L = 0)কাজ
0 0 120HNon-specific EOI: ISR-এর সবচেয়ে উঁচু বিট মোছে
0 1 160H + LSpecific EOI: বিট L মোছে
1 0 1A0HRotate on non-specific EOI: মোছে, আর সেই level সবচেয়ে নিচু হয়
1 1 1E0H + LRotate on specific EOI: বিট L মোছে, L সবচেয়ে নিচু
1 1 0C0H + LSet priority: L সবচেয়ে নিচু, কোনো বিট মোছে না
1 0 0 / 0 0 080H / 00HAEOI-তে rotation চালু / বন্ধ
0 1 040Hকিছুই না (no operation)

ISR-এর বিট কেন নিজে থেকে মোছে না? কারণ 8259 জানে না ISR কখন শেষ হলো; সেটি জানে শুধু software. বিট বসে থাকা মানে “এই level-এর কাজ চলছে”, আর fully nested নিয়মে তখন সমান বা নিচু অগ্রাধিকারের সবাই আটকে থাকে। তাই ISR-এর শেষে, IRET-এর ঠিক আগে, একটি EOI দিতেই হয়। AEOI (ICW4-এর AEOI = 1) এই ঝামেলা বাঁচায়, শেষ INTA̅-এর শেষে বিট নিজেই মোছে, কিন্তু তখন ISR-এর মাঝেই সমান বা নিচু অগ্রাধিকারের interrupt ঢুকতে পারে, IF = 1 হলেই; datasheet তাই বলে, nested বহুস্তর কাঠামো না লাগলে তবেই AEOI.

EOI ভুলে গেলে — সত্যিকারের run

pic86.asm-এর একটি সংস্করণে alarm-এর ISR (IR1) EOI দিতে ভুলে গেছে, বাকি সব এক (noeoi86.asm, লেখকের lab-এ). Alarm আসে ৪০তম নির্দেশে, tare ৬০-এ, UART ৯০-এ:

$ python -B run8259.py noeoi86.asm --ir 40:1 --ir 60:2 --ir 90:0 --max 3000
8259| OUT F0h <- 13h  ICW1                     IRR=00000000 ISR=00000000 IMR=00000000
8259| OUT F2h <- 40h  ICW2                     IRR=00000000 ISR=00000000 IMR=00000000
8259| OUT F2h <- 01h  ICW4                     IRR=00000000 ISR=00000000 IMR=00000000
8259| OUT F2h <- F8h  OCW1 (IMR)               IRR=00000000 ISR=00000000 IMR=11111000
8259| step 40: IR1 raised  IRR=00000010 ISR=00000000 IMR=11111000
8259| INTR -> 2 x INTA, IR1, type 41h   IRR=00000000 ISR=00000010 IMR=11111000
A
8259| step 60: IR2 raised  IRR=00000100 ISR=00000010 IMR=11111000
8259| step 90: IR0 raised  IRR=00000101 ISR=00000010 IMR=11111000
8259| INTR -> 2 x INTA, IR0, type 40h   IRR=00000100 ISR=00000011 IMR=11111000
U
8259| OUT F0h <- 20h  OCW2 non-specific EOI    IRR=00000100 ISR=00000010 IMR=11111000
[error: stopped after 3000 instructions without INT 21h/4Ch, 2998 instructions]

Alarm-এর ISR ঠিকঠাক চলেছে, IRET-ও করেছে; CPU-র দিক থেকে সব স্বাভাবিক। কিন্তু 8259-এর খাতায় ISR = 00000010 থেকে গেল। Tare (IR2) এসে IRR-এ বসল, আর সেখানেই আটকে রইল, কারণ “IR1-এর সেবা চলছে” আর IR2 তার চেয়ে নিচু। UART (IR0) উঁচু বলে ঢুকতে পেরেছে (ISR = 00000011), আর তার নিজের EOI শুধু নিজের বিট মুছেছে। ৩০০০ নির্দেশ পরে runner থেমেছে, তখনো tare-এর জন্য অপেক্ষা। বাস্তবে ফল: দোকানদার বোতাম চাপছেন, scale সাড়া দিচ্ছে না, অথচ serial লাইন আর alarm ঠিক কাজ করছে। এই ধরনের ভুল debugger-এ ধরা কঠিন, কারণ কোনো নির্দেশ ভুল নয়; সমাধান হলো OCW3 দিয়ে ISR register পড়ে দেখা।

Non-specific না specific — কখন কোনটি

Non-specific EOI ধরে নেয়, ISR-এর সবচেয়ে উঁচু বিটটিই এইমাত্র শেষ হওয়া কাজ। Fully nested mode-এ তা সবসময় সত্য, কারণ ভেতরের (সবচেয়ে সাম্প্রতিক) interrupt সবসময় সবচেয়ে উঁচু। কিন্তু চলার মাঝে অগ্রাধিকার বদলালে এই অনুমান ভাঙে, আর datasheet তখন specific EOI বাধ্যতামূলক বলে। নিচের মডেলে tare-এর ISR চলছে, তার ভেতরে UART ঢুকেছে; UART-এর ISR এক কারণে “set priority” দিয়ে IR0-কে সবচেয়ে নিচু করল, তারপর EOI দিল।

# Non-specific বনাম specific EOI: অগ্রাধিকার বদলালে কোনটি নিরাপদ
from pic8259 import PIC

def nested():                  # tare (IR2) চলছে, তার ভেতরে UART (IR0)
    p = PIC()
    for a0, v in ((0, 0x13), (1, 0x40), (1, 0x01), (1, 0xF8)):
        p.write(a0, v)
    p.request(2); p.inta()
    p.request(0); p.inta()
    return p

for label, eoi in (("non-specific 20H", 0x20), ("specific 60H", 0x60)):
    p = nested()
    print(f"--- UART ISR শেষে {label}")
    print(f"শুরু            ISR={p.isr:08b}  ক্রম {p.order()}")
    p.write(0, 0xC0)           # set priority: IR0 সবচেয়ে নিচু
    print(f"OCW2 C0H-এর পরে ISR={p.isr:08b}  ক্রম {p.order()}")
    p.write(0, eoi)            # UART ISR-এর EOI
    print(f"EOI {eoi:02X}H-এর পরে ISR={p.isr:08b}")
    p.write(0, 0x62)           # tare ISR-এর specific EOI (IR2)
    p.request(0)               # UART-এর পরের byte এল
    print(f"tare শেষে ISR={p.isr:08b}, নতুন UART-এ INT={int(p.int_pin())}")

আসল আউটপুট (ব্রাউজারের Python):

--- UART ISR শেষে non-specific 20H
শুরু            ISR=00000101  ক্রম [0, 1, 2, 3, 4, 5, 6, 7]
OCW2 C0H-এর পরে ISR=00000101  ক্রম [1, 2, 3, 4, 5, 6, 7, 0]
EOI 20H-এর পরে ISR=00000001
tare শেষে ISR=00000001, নতুন UART-এ INT=0
--- UART ISR শেষে specific 60H
শুরু            ISR=00000101  ক্রম [0, 1, 2, 3, 4, 5, 6, 7]
OCW2 C0H-এর পরে ISR=00000101  ক্রম [1, 2, 3, 4, 5, 6, 7, 0]
EOI 60H-এর পরে ISR=00000100
tare শেষে ISR=00000000, নতুন UART-এ INT=1

প্রথম অংশে non-specific EOI (20H) মুছেছে IR2-এর বিট, কারণ নতুন ক্রমে [1, 2, …, 7, 0] IR2 এখন IR0-এর চেয়ে উঁচু। ফল দ্বিগুণ খারাপ: tare-এর কাজ চলার মাঝেই তার বিট হারাল, আর UART-এর বিট (00000001) চিরকাল বসে রইল, তাই নতুন UART byte-এ INT = 0. দ্বিতীয় অংশে specific EOI (60H = 011 00 000, L = 0) ঠিক IR0-এর বিটটিই মুছেছে; tare নিজের 62H দিয়ে শেষ করার পরে নতুন UART অনুরোধ সঙ্গে সঙ্গে INT পেয়েছে।

8259-এর অবস্থা
ঘটনা
ISR
অগ্রাধিকার
ফল
  1. শুরু। Tare-এর ISR (IR2) চলছিল, STI দিয়েছিল, তাই UART (IR0) ঢুকে পড়েছে। ISR = 00000101, ক্রম শুরুর নিয়মে, IR0 সবচেয়ে উঁচু। এই মুহূর্তে চলছে UART-এর ISR.
  2. Set priority, C0H. R = 1, SL = 1, EOI = 0, L = 0: IR0 সবচেয়ে নিচু, ক্রম এখন IR1, IR2, …, IR7, IR0. ISR-এ কিছু বদলায়নি, কিন্তু 8259-এর চোখে এখন IR2-ই “সবচেয়ে উঁচু চলতি কাজ”।
  3. ভুল পথ, non-specific 20H. 8259 সবচেয়ে উঁচু বিটটি মোছে, যা এখন IR2: ISR = 00000001. Tare-এর ISR এখনো চলছে, অথচ তার বিট নেই; আর UART শেষ হলেও তার বিট রয়ে গেল।
  4. পরিণতি। Tare-এর specific EOI (62H) এখন আর মোছার কিছু পায় না। নতুন UART byte এলে IR0-এর অনুরোধ নিজের বসে থাকা বিটের কারণেই আটকায়: INT = 0, serial data হারাতে শুরু করবে।
  5. ঠিক পথ, specific 60H. ধাপ ২-এর পর থেকে আবার: R = 0, SL = 1, EOI = 1, L = 0. 8259 অনুমান করে না, ঠিক IR0-এর বিট মোছে: ISR = 00000100, tare-এর বিট অক্ষত।
  6. পরিণতি। Tare শেষে 62H দেয়, ISR = 00000000. নতুন UART-এর অনুরোধে INT = 1. নিয়ম: অগ্রাধিকার যেখানে বদলায় (rotation, set priority, special mask), সেখানে প্রতিটি ISR নিজের level-এর specific EOI দেবে।

৬ · Fully nested, rotation, special mask আর poll

Fully nested mode শুরুর নিয়ম: IR0 উঁচু, IR7 নিচু, আর ISR-এ কোনো বিট বসে থাকলে সমান বা নিচু সবাই আটকে থাকে, উঁচুরা ঢুকতে পারে, যদি CPU-র IF আবার চালু করা হয়। 8086-এ interrupt নেওয়ার সময় IF = 0 হয় (পর্ব ২০), তাই nesting চাইলে ISR-কে নিজে STI দিতে হয়। নিচের run-এ tare-এর ISR শুরুতেই STI দেয়, তারপর একটি লম্বা কাজ (এখানে ২০ পাকের LOOP) করে; মাঝে UART আসে, আর UART-এর ISR OCW3 (0BH) দিয়ে ISR register পড়ে।

$ python -B run8259.py nest86.asm --ir 30:2 --ir 36:0
8259| OUT F0h <- 13h  ICW1                     IRR=00000000 ISR=00000000 IMR=00000000
8259| OUT F2h <- 40h  ICW2                     IRR=00000000 ISR=00000000 IMR=00000000
8259| OUT F2h <- 01h  ICW4                     IRR=00000000 ISR=00000000 IMR=00000000
8259| OUT F2h <- F8h  OCW1 (IMR)               IRR=00000000 ISR=00000000 IMR=11111000
8259| step 30: IR2 raised  IRR=00000100 ISR=00000000 IMR=11111000
8259| INTR -> 2 x INTA, IR2, type 42h   IRR=00000000 ISR=00000100 IMR=11111000
8259| step 36: IR0 raised  IRR=00000001 ISR=00000100 IMR=11111000
8259| INTR -> 2 x INTA, IR0, type 40h   IRR=00000000 ISR=00000101 IMR=11111000
8259| OUT F0h <- 0Bh  OCW3                     IRR=00000000 ISR=00000101 IMR=11111000
8259| IN  F0h -> 05h
8259| OUT F0h <- 20h  OCW2 non-specific EOI    IRR=00000000 ISR=00000100 IMR=11111000
8259| OUT F0h <- 20h  OCW2 non-specific EOI    IRR=00000000 ISR=00000000 IMR=11111000
[exit code 0 via INT 21h/4Ch, 73 instructions]

লগ নিজেই গল্প বলে। Tare আসে, ISR = 00000100. ছয় নির্দেশ পরে UART আসে, আর tare-এর কাজ শেষ না হলেও সঙ্গে সঙ্গে ঢোকে, কারণ IR0 উঁচু আর IF = 1: ISR = 00000101, একটি nested interrupt. UART-এর ISR register পড়ে পেয়েছে 05h, অর্থাৎ দুটি level একসঙ্গে “সেবায়”। প্রথম EOI মুছেছে IR0 (সবচেয়ে উঁচু), দ্বিতীয়টি tare-এর IR2. এখানে non-specific EOI নিরাপদ, কারণ অগ্রাধিকার কেউ বদলায়নি। nest86.asm-এর পুরো কোড লেখকের lab-এ; গঠন pic86.asm-এর মতো, শুধু tare-এর ISR-এ sti আর UART-এর ISR-এ mov al, 0Bh, out 0F0h, al, in al, 0F0h.

Rotating priority সমান গুরুত্বের যন্ত্রের জন্য। ধরুন বাজারঘরে তিনটি একই রকম scale, তিনটি IR-এ; fully nested নিয়মে IR0-এর scale সারাক্ষণ ব্যস্ত থাকলে বাকি দুটি কখনো সুযোগ পাবে না। Automatic rotation-এ (OCW2 = A0H, rotate on non-specific EOI) যে level এইমাত্র সেবা পেল, সে সবচেয়ে নিচুতে চলে যায়; datasheet-এর ভাষায়, সবচেয়ে খারাপ ক্ষেত্রেও একটি যন্ত্রকে বাকি সাতজনের একবার করে সেবা পর্যন্ত অপেক্ষা করতে হয়। Specific rotation-এ software নিজে ঠিক করে কে সবচেয়ে নিচু (set priority, C0H + L).

# সমান গুরুত্বের যন্ত্র: fully nested বনাম automatic rotation
from pic8259 import PIC

def run(eoi, rounds=9):
    p = PIC()
    for a0, v in ((0, 0x13), (1, 0x40), (1, 0x01), (1, 0xF8)):
        p.write(a0, v)
    served = []
    for _ in range(rounds):
        for n in (0, 1, 2):
            p.request(n)       # তিন যন্ত্রই সারাক্ষণ অনুরোধ করছে
        _, n = p.inta()
        served.append(n)
        p.write(0, eoi)
    return served, p.order()

for label, eoi in (("non-specific EOI 20H", 0x20), ("rotate on EOI A0H", 0xA0)):
    served, order = run(eoi)
    print(f"{label:21}: সেবা পেল IR{served}")
    print(f"{'':21}  শেষে অগ্রাধিকার {order}")

p = PIC()                      # datasheet-এর উদাহরণ: IS4 আর IS6 চালু
p.write(0, 0x13); p.write(1, 0x40); p.write(1, 0x01); p.write(1, 0x00)
p.isr = 0b01010000
p.write(0, 0xA0)               # IR4-এর কাজ শেষ, rotate
print(f"datasheet: ISR={p.isr:08b}, সবচেয়ে উঁচু IR{p.order()[0]}, "
      f"সবচেয়ে নিচু IR{p.order()[-1]}")

আসল আউটপুট (ব্রাউজারের Python):

non-specific EOI 20H : সেবা পেল IR[0, 0, 0, 0, 0, 0, 0, 0, 0]
                       শেষে অগ্রাধিকার [0, 1, 2, 3, 4, 5, 6, 7]
rotate on EOI A0H    : সেবা পেল IR[0, 1, 2, 0, 1, 2, 0, 1, 2]
                       শেষে অগ্রাধিকার [3, 4, 5, 6, 7, 0, 1, 2]
datasheet: ISR=01000000, সবচেয়ে উঁচু IR5, সবচেয়ে নিচু IR4

তিন যন্ত্রই প্রতি পাকে অনুরোধ করছে। সাধারণ EOI-তে নয়বারই সেবা পেয়েছে IR0; IR1 আর IR2-এর জন্য এটি interrupt latency-র সীমাহীন বৃদ্ধি, যাকে starvation বলে। Rotate on EOI-তে ক্রম 0, 1, 2, 0, 1, 2…: প্রত্যেকে পালা করে। শেষ লাইনটি datasheet-এর নিজের উদাহরণ: IS4 আর IS6 চালু অবস্থায় IR4-এর কাজ শেষে rotate করলে ISR = 01000000, সবচেয়ে উঁচু IR5, সবচেয়ে নিচু IR4, ঠিক datasheet-এর “After Rotate” ছবির মতো।

Special mask mode (OCW3 = 68H চালু, 48H বন্ধ) উল্টো সমস্যার সমাধান: একটি লম্বা ISR চায় তার কাজের কিছু অংশে নিচু অগ্রাধিকারের interrupt-ও ঢুকুক। সাধারণ mode-এ তা অসম্ভব, কারণ নিজের ISR বিটই সবাইকে আটকায়। Special mask mode-এ ISR নিজের level-কে OCW1-এ mask করলে, বাকি সব খোলা level, নিচু হোক বা উঁচু, ঢুকতে পারে। এই mode-এ non-specific EOI masked level-এর বিট মোছে না, তাই এখানে specific EOI-ই নিরাপদ।

Poll command (OCW3 = 0CH) 8259-কে interrupt ছাড়াই ব্যবহারের উপায়: CPU-র INTR-এ INT না জুড়ে বা IF বন্ধ রেখে, software OCW3-এ P = 1 লিখে পরের IN (A0 = 0) পড়ে। 8259 সেই পড়াকে INTA ধরে নেয়, ISR বিট বসায়, আর দেয় একটি poll word: D7 = 1 যদি কোনো অনুরোধ থাকে, D2–D0 = সবচেয়ে উঁচু অনুরোধের level. মডেলে IR2 অনুরোধ করলে poll word 82H. Datasheet দুটি ব্যবহার বলে: অনেক level-এর জন্য একটিই ছোট routine, আর ৬৪-এর বেশি level-এ বাড়ানো।

Edge বনাম level (ICW1-এর LTIM): edge mode-এ 0 → 1 পরিবর্তনই অনুরোধ, লাইন উঁচু থেকে গেলেও আরেকটি interrupt হয় না (edge-triggered). Level mode-এ উঁচু থাকলেই অনুরোধ (level-triggered); তাই EOI দেওয়ার বা CPU-র interrupt আবার খোলার আগে যন্ত্রকে লাইন নামাতে হয়, না হলে একই ISR বারবার চলে।

৭ · Cascade — master, slave আর ৬৪টি level

আটটির বেশি লাইন লাগলে একাধিক 8259 জোড়া হয়, যাকে cascade mode বলে। একটি master CPU-র INTR-এ বসে; প্রতিটি slave-এর INT যায় master-এর একটি IR-এ। আটটি IR-এ আটটি slave বসালে ৮ × ৮ = ৬৪টি level, datasheet-এর সর্বোচ্চ। Master বা slave কে, তা ঠিক হয় SP̅/EN̅ pin দিয়ে (non-buffered mode-এ 1 = master, 0 = slave) বা buffered mode-এ ICW4-এর M/S বিট দিয়ে।

ছবি ২৬.২ — একটি master আর একটি slave (slave বসেছে master-এর IR2-এ)

CAS0–CAS2-এর তিনটি তারে master জানায় কোন slave vector দেবে

8259 master আর slave CPU · INTR INT Master ICW3 = 04H IR0, IR1, IR3–7 IR2 ← slave SP̅/EN̅ = +5 V Slave ICW3 = 02H IR0–IR7, ID = 2 INT → master SP̅/EN̅ = 0 V CAS0–CAS2 (master → slave)
ছবি ২৬.২ — INTA̅ আর D7–D0 দুটি chip-এই যায় (ছবিতে আঁকা হয়নি). Slave-এর ICW3 = 02H মানে তার ID 2, কারণ সে master-এর IR2-এ বসেছে; master-এর ICW3 = 04H (বিট 2 = 1) মানে IR2-এ একটি slave আছে।

যাত্রাটি এমন: slave-এর কোনো IR উঠলে slave-এর INT ওঠে, যা master-এর IR2-এ অনুরোধ। Master নিজের resolver চালায়; IR2 জিতলে প্রথম INTA̅-তে master CAS0–CAS2-এ slave-এর ID (010) রাখে, আর সেই ID-র slave পরের pulse-এ vector দেয় (8086-এ দ্বিতীয় INTA̅-এ type; 8085-এ ২য় আর ৩য় byte). PC/AT ধাঁচের প্রচলিত বিন্যাসে, যেখানে master-এর type 08H–0FH আর slave-এর 70H–77H, মডেলে চালালে (লেখকের lab-এর cascade.py):

slave IR4 raised : master INT = 1
INTA: master IR2 (slave ID 2 on CAS0-2), type from slave = 74h
 master IRR=00000000 ISR=00000100 IMR=00000000
 slave  IRR=00000000 ISR=00010000 IMR=00000000
master IR0 and IR3 raised -> chosen IR0
EOI to slave, then to master:
 master IRR=00001001 ISR=00000000 IMR=00000000
 slave  IRR=00000000 ISR=00000000 IMR=00000000

Slave-এর IR4 → type 70H + 4 = 74H, আর দুটি chip-এই ISR-এর বিট বসেছে: master-এ IR2, slave-এ IR4. তাই EOI দিতে হয় দুবার, আগে slave-কে, তারপর master-কে; datasheet-ও তা-ই বলে। একটি সূক্ষ্মতা: master-এর IR2 সেবায় থাকা অবস্থায় একই slave-এর আরও উঁচু অনুরোধ (ধরুন slave-এর IR1) সাধারণ fully nested mode-এ master পার হতে পারে না, কারণ master-এর চোখে IR2 = IR2. এর সমাধান special fully nested mode (master-এর ICW4-এ SFNM = 1): তখন master একই level-এর নতুন অনুরোধও ছাড়ে। কিন্তু তখন ISR-এর শেষে slave-কে EOI দিয়ে slave-এর ISR register পড়তে হয়, শূন্য হলে তবেই master-কে EOI, কারণ slave-এ আরেকটি কাজ তখনো চলতে পারে। মডেলের test-এ দুটি ক্ষেত্রই যাচাই করা: SFNM ছাড়া slave-এর IR1 আটকে থাকে, SFNM-সহ ঢোকে (type 71H).

সাবধান: Slave-এর ISR-এ শুধু master-কে EOI দেওয়া একটি পরিচিত ভুল। Master খুলে যায়, কিন্তু slave-এর বিট বসে থাকে, আর সেই slave-এর সমান বা নিচু সব লাইন নীরবে আটকে যায়: অংশ ৫-এর “EOI ভুলে গেলে”-র মতো, তবে খোঁজা আরও কঠিন, কারণ master-এর ISR register পরিষ্কার দেখায়।

আরও গভীরে: Datasheet-এর Figure 9-এ প্রতিটি IR-এর “priority cell”-এর সরল logic আঁকা: edge sense latch, একটি transparent D latch-এর request latch, mask latch আর in-service latch; INTA-এর সময় FREEZE সংকেত request latch-গুলোকে জমিয়ে দেয়, যাতে resolver-এর সিদ্ধান্তের মাঝে IRR না বদলায়। Datasheet আরও জানায়, দুই INTA̅-এর মাঝে উঁচু কোনো অনুরোধ এলে INT দ্বিতীয় pulse-এর পরে সাময়িক নেমে আবার ওঠে, আর সেই বিরতির দৈর্ঘ্য নির্দিষ্ট নয়, chip-ভেদে আলাদা। Datasheet প্রথমে বলে AEOI শুধু master-এ চলে, তারপর যোগ করে, ১৯৮৫ বা তার পরের copyright-এর 8259A slave হিসেবেও AEOI-তে চলে। আধুনিক PC-তে আলাদা 8259 chip আর নেই, কিন্তু chipset-এর ভেতরে এর সমতুল্য রাখা হয় পুরোনো software-এর জন্য, আর অনেক OS চালু হয়েই সেটিকে mask করে APIC-এ চলে যায়।

পরীক্ষা ও ইন্টারভিউতে: “ICW কয়টি, কোনগুলো বাধ্যতামূলক?” → চারটি; ICW1 আর ICW2 সবসময়, ICW3 শুধু cascade-এ (SNGL = 0), ICW4 শুধু IC4 = 1 হলে (8086-এ সবসময়). “IRR, ISR, IMR-এর পার্থক্য?” → অনুরোধ জমা, সেবা চলছে, mask; IMR IRR-কে বদলায় না। “Non-specific EOI-এর byte?” → OCW2 = 20H. “ICW2 = 40H হলে IR5-এর type?” → 45H, vector 00114H-এ। “8085 mode-এ INTA কয়টি?” → তিনটি: CALL (CDH), নিচু byte, উঁচু byte. “সর্বোচ্চ কত level?” → ৬৪, একটি master আর আটটি slave.

৮ · AI-এর যুগে 8259 যাচাই

8259 নিয়ে AI assistant-এর উত্তর সাধারণত আত্মবিশ্বাসী আর প্রায়-ঠিক হয়। ভুলগুলো লুকিয়ে থাকে বিটের ক্রমে, word-এর ক্রমে আর 8085 বনাম 8086 mode-এ, ঠিক যেখানে পরীক্ষায় নম্বর কাটে আর বাস্তবে বোর্ড চুপ হয়ে যায়।

AI প্রায়ই যা করেকীভাবে ধরবেন
8086-এর জন্য ICW4 বাদ দেয়, বা IC4 = 0 রাখেIC4 = 0 মানে µPM = 0, অর্থাৎ 8085 mode; datasheet-এর ICW1-এর তালিকা দেখুন
ICW1-এর D4 = 1 ভুলে যায়, বা OCW2-কে A0 = 1-এ পাঠায়প্রতিটি byte-কে binary-তে লিখে টেবিলের সঙ্গে মেলান; ভুল port-এর পরিণতি অনুশীলন ২-এ
Single 8259-এ ICW3 লিখে ফেলেSNGL = 1 হলে বাড়তি byte-টি ICW4 হয়ে যায়; মডেলে ক্রম চালিয়ে দেখুন
ISR-এ EOI ভুলে যায়, বা cascade-এ শুধু একটি chip-কে দেয়OCW3 = 0BH দিয়ে ISR register পড়ুন; run-এ নিচু লাইন আটকে যায় কি না দেখুন
Rotation বা set priority-র সঙ্গে non-specific EOI দেয়অংশ ৫-এর নিয়ম: অগ্রাধিকার বদলালে specific EOI
8085 mode-এর CALL ঠিকানা ভুল হিসাব করে (interval 4 আর 8 গুলিয়ে)ADI দেখে বিট বসিয়ে হাতে হিসাব; মডেলের inta() চালিয়ে মেলান
Pin নম্বর বা সময়ের মান বানিয়ে বলেIntel-এর datasheet (231468)-এর pin টেবিল আর AC characteristics

AI-কে কাজে লাগাতে প্রসঙ্গ আর যাচাইয়ের শর্ত শুরুতেই দিন:

আমি Intel 8259A শিখছি, Intel 8086-এর সঙ্গে (minimum mode), NASM syntax-এ। 8259-এর A0 pin CPU-র A1-এ, port 0F0h (A0=0) আর 0F2h (A0=1). ১. একটি 8259, edge-triggered, type 40h থেকে, normal EOI-এর জন্য ICW1, ICW2, ICW4 আর OCW1 (শুধু IR0–IR2 খোলা)-এর byte দাও। প্রতিটি byte-এর প্রতিটি বিটের মানে টেবিলে বলো। ২. IR1-এর জন্য একটি ISR লেখো যা register রাখে, শেষে ঠিক port-এ EOI দেয়, তারপর IRET. ৩. IR1 আর IR2 একসঙ্গে এলে IRR আর ISR-এর মান প্রতিটি INTA আর EOI-এর পরে কী হবে, ধাপে ধাপে দেখাও। ৪. কোনো pin নম্বর বা সময়ের মান দিলে Intel-এর 8259A datasheet থেকে দাও; নিশ্চিত না হলে "নিশ্চিত নই" বলো। 8085 mode-এর কিছু মেশাবে না।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১Interrupt-এর অগ্রাধিকার সামলানোর কাজটি CPU-র ভেতরে না রেখে Intel কেন 8259A নামে আলাদা chip-এ রাখল? আজকের microcontroller-এ সেই সিদ্ধান্ত কোথায় গেল?

১৯৭০-এর দশকে একটি chip-এ কতগুলো transistor বসানো যায়, তার সীমা ছিল কঠোর, আর pin-এর সংখ্যাও। 8085 আর 8086 দুটিই 40-pin package; 8086-কে তো minimum আর maximum mode-এ একই pin-কে দুই কাজে লাগাতে হয়েছে (পর্ব ২১). আটটি IR লাইন, cascade-এর তিনটি তার আর mask-এর register CPU-তে ঢোকালে আরও এক ডজন pin আর অনেক transistor লাগত, যা সব গ্রাহকের দরকার ছিল না। একটি ছোট খেলনা বা যন্ত্রে হয়তো একটিমাত্র interrupt; সেখানে বাড়তি circuit-এর খরচ বৃথা।

আলাদা chip হওয়ার দ্বিতীয় লাভ নমনীয়তা। একই 8259A 8080, 8085 আর 8086 তিন প্রজন্মের CPU-র সঙ্গেই চলে (datasheet-এর প্রথম পাতায় MCS-80, MCS-85 আর 8086/8088 সামঞ্জস্যের কথা), শুধু ICW4-এর একটি বিট বদলে। যার আটটির বেশি লাইন দরকার, সে cascade করে, যার দরকার নেই, সে chip-টিই বাদ দেয়। IBM PC এই পথে একটি 8259A নিয়েছিল, আর PC/AT-এ আরেকটি যোগ করে ১৫টি ব্যবহারযোগ্য লাইন পেয়েছিল, কারণ একটি লাইন slave-কে জুড়তে খরচ হয়।

দাম ছিল গতি আর জটিলতায়। প্রতিটি interrupt-এ CPU-কে বাইরের chip-এর সঙ্গে bus cycle চালাতে হয় (INTA̅), প্রতিটি ISR-এর শেষে আরেকটি OUT দিয়ে EOI, আর দুই chip-এর অবস্থা (IF আর ISR register) মিলিয়ে রাখার দায়িত্ব programmer-এর। এই পর্বের EOI-ভুলের run দেখিয়েছে, দায়িত্বটি কত সহজে ভোলা যায়।

Transistor সস্তা হওয়ার পরে পাল্লা উল্টে গেছে। ARM Cortex-M-এ interrupt controller, NVIC, CPU-র একেবারে ভেতরে: অগ্রাধিকার প্রতিটি লাইনের register-এ, vector সরাসরি টেবিল থেকে, আর EOI-এর আলাদা নির্দেশই নেই, কারণ exception থেকে ফেরার সময় hardware নিজে জানে কোন কাজ শেষ হলো। পর্ব ৩০ (Cortex-M-এর exception আর NVIC)-এ তা দেখবেন; সেখানে 8259-এর IRR, ISR আর IMR-এর ছায়া চিনতে পারবেন pending, active আর enable register-এ।

মূল উপলব্ধি: কোন কাজ কোন chip-এ থাকবে, তা ঠিক করে প্রযুক্তির খরচ; 8259 আলাদা ছিল কারণ তখন transistor আর pin দামি ছিল, NVIC ভেতরে কারণ এখন latency আর সরলতা দামি।

প্র ০২IBM PC তার 8259-এর ICW2 দিয়ে hardware interrupt-কে type 08H–0FH-এ বসিয়েছিল। পরে protected mode-এ এই পছন্দ কেন সমস্যা হলো, আর ICW2 প্রোগ্রাম করা যায় বলে কীভাবে সমাধান সম্ভব হলো?

পর্ব ২০-এ দেখেছেন, Intel 8086-এর manual type 0–31-কে Intel-এর নিজের জন্য সংরক্ষিত বলেছিল। ১৯৮১ সালের IBM PC সেই সতর্কতা পুরো মানেনি: BIOS 8259-এর ICW2 = 08H লিখে IRQ0–IRQ7-কে type 08H–0FH-এ বসাল, যেখানে IRQ0 timer, IRQ1 keyboard. 8086/8088-এ তখন type 8–15 অন্য কোনো কাজে ছিল না, তাই সমস্যা দেখা যায়নি।

80286 আর বিশেষ করে 80386-এর protected mode-এ Intel সেই সংরক্ষিত নম্বরগুলো সত্যিই ব্যবহার করল CPU-র নিজের exception-এর জন্য: type 8 হলো double fault, type 13 general protection fault, type 14 (386) page fault ইত্যাদি। এখন timer-এর IRQ0 আর double fault একই type 8-এ এলে handler বুঝবে কী করে কে ডেকেছে? Stack-এ error code থাকে কি না, তা-ও আলাদা, তাই ভুল অনুমানে stack-ই এলোমেলো হয়ে যায়।

সমাধান ছিল 8259-এর নকশাতেই: ICW2 software দিয়ে লেখা যায়। Protected mode-এর OS চালু হওয়ার সময় দুটি 8259-কে নতুন ICW1–ICW4 দিয়ে আবার শুরু করে, ICW2-তে 20H বা তার ওপরের কোনো মান দিয়ে, যাতে hardware interrupt Intel-এর সংরক্ষিত পরিসর থেকে সরে যায়। এই কাজকে চলতি ভাষায় “PIC remap” বলে, আর অনেক hobby OS টিউটোরিয়ালের প্রথম দিকের ধাপ এটিই। যদি type 8259-এর ভেতরে বাঁধা থাকত, যেমন 8085-এর RST 7.5-এর 003CH বাঁধা, তাহলে এই সংঘাত কোনো software দিয়ে মেটানো যেত না।

এখান থেকে একটি নকশার শিক্ষা নেওয়া যায়: যে সংখ্যা ভবিষ্যতে সংঘাতে পড়তে পারে, তা configurable রাখা। আবার উল্টো শিক্ষাও আছে: সংরক্ষিত বলে দেওয়া নম্বর ব্যবহার করলে, আজ চললেও কাল তার দাম দিতে হয়। বাজারঘরের নকশায় তাই ICW2 = 40H, নিরাপদ পরিসরে।

মূল উপলব্ধি: ICW2-এর মতো একটি ছোট configurable byte কয়েক প্রজন্মের সামঞ্জস্য বাঁচিয়েছে; hardware-এর মান বাঁধা না রেখে software-কে বদলাতে দেওয়া দীর্ঘ জীবনের যন্ত্রে বড় সুবিধা।

প্র ০৩বাজারঘরে UART-কে IR0 আর cold-room alarm-কে IR1 দেওয়া হয়েছে, যদিও alarm-ই বেশি “গুরুত্বপূর্ণ”। এই যুক্তি কি সবসময় খাটে? কোন পরিস্থিতিতে উল্টোটা ঠিক হতো?

Interrupt-এর অগ্রাধিকার আসলে একটি প্রশ্নের উত্তর: কোন কাজ কত কম সময়ের মধ্যে শুরু না হলে ক্ষতি হয়? UART-এর ক্ষেত্রে ক্ষতিটি নিশ্চিত আর দ্রুত: পুরোনো ধরনের UART-এ একটি-দুটি byte-এর buffer থাকে, 9600 baud-এ নতুন byte আসে প্রায় প্রতি 1.04 ms-এ, আর আগেরটি না পড়লে overrun হয়ে data হারায়। Cold-room alarm-এর সিদ্ধান্ত আসে কয়েক সেকেন্ডে (প্রতি 1 s-এ পড়া, পরপর তিনটি), তাই তার ISR কয়েক মিলিসেকেন্ড দেরিতে শুরু হলে খাবারের কোনো ক্ষতি নেই। এই কারণে “গুরুত্ব” নয়, “deadline”-ই অগ্রাধিকার ঠিক করে, যা real-time তত্ত্বের rate monotonic নিয়মের সঙ্গেও মেলে: যার সময়সীমা ছোট, তার অগ্রাধিকার উঁচু (পর্ব ৫৬).

তবে কয়েকটি শর্তে উত্তর বদলায়। প্রথমত, যদি UART-এ বড় FIFO থাকে (পরের প্রজন্মের UART-এ ১৬ byte-এর FIFO আসে), তাহলে UART-এর deadline অনেক ঢিলা, আর তাকে নিচে নামানো যায়। দ্বিতীয়ত, যদি alarm-এর লাইনটি আসলে একটি নিরাপত্তা-সংকেত হয়, যেমন compressor-এর অতিরিক্ত current, যেখানে কয়েক মিলিসেকেন্ডে মোটর পুড়তে পারে, তাহলে তার deadline সবচেয়ে ছোট, আর তাকে উঁচুতে বা NMI-তে দেওয়াই ঠিক। তৃতীয়ত, অগ্রাধিকার শুধু শুরু কখন হবে তা ঠিক করে; উঁচু ISR যদি লম্বা হয়, নিচুগুলোর latency বাড়ে। তাই UART-এর ISR-কে এক byte পড়ে ring buffer-এ রাখার বেশি কিছু করা উচিত নয়।

আরেকটি দিক হলো fully nested mode-এর কাঠামো। বাজারঘরের tare ISR যদি লম্বা হিসাব করে, তার শুরুতে STI দিলে UART আর alarm দুটিই তাকে থামাতে পারে, যেমন nest86-এর run-এ UART থামিয়েছে। কিন্তু STI না দিলে 8259 অনুমতি দিলেও CPU নিজে দরজা বন্ধ রাখবে, আর UART-এর byte হারাবে।

মূল উপলব্ধি: অগ্রাধিকার বেছে নিন deadline দেখে, অনুভূতির গুরুত্ব দেখে নয়; আর উঁচু অগ্রাধিকারের ISR ছোট রাখুন, যাতে নিচুদের অপেক্ষা সীমার মধ্যে থাকে।

প্র ০৪8259 কেন IR লাইন প্রথম INTA̅ পর্যন্ত উঁচু থাকার শর্ত দেয়, আর শর্ত ভাঙলে IR7 দেয়? এই “default IR7” কি নকশার দুর্বলতা, না সুবিধা?

INT ওঠা আর CPU-র INTA̅ দেওয়ার মধ্যে একটি সময় থাকে: CPU-কে চলতি নির্দেশ শেষ করতে হয়, 8086-এ কোনো লম্বা DIV বা string নির্দেশ হলে তা কয়েক মাইক্রোসেকেন্ডও হতে পারে। 8259-এর resolver সিদ্ধান্ত চূড়ান্ত করে প্রথম INTA̅-তে, কারণ তখনই IRR জমিয়ে (datasheet-এর FREEZE) ISR-এর বিট বসানো হয়। এর মাঝে লাইনটি নেমে গেলে request latch আর কিছু ধরে রাখে না; অথচ CPU এর মধ্যে INTA̅ চক্র শুরু করে দিয়েছে, তাকে কিছু একটা vector দিতেই হবে। 8259 তখন IR7-এর vector দেয়, কিন্তু IR7-এর ISR বিট বসায় না।

লাইন এত তাড়াতাড়ি নামে কেন? বাস্তব কারণ সাধারণত noise: একটি দীর্ঘ তারে মোটর চালু হওয়ার spike, একটি bounce-করা বোতাম (পর্ব ৪২-এ debouncing), বা যন্ত্রের নিজের ভুল। Edge mode-এ একটি ছোট spike-ও IRR-এর বিট বসাতে পারে। তাই datasheet নিজেই পরামর্শ দেয়: IR7-এর routine-কে noise ধরার “পরিষ্কারক” হিসেবে ব্যবহার করুন, যা কিছু না করে ফিরে আসে। IR7-এ সত্যিকারের যন্ত্র থাকলে ISR register পড়ে আলাদা করা যায়: আসল IR7-এ বিট 7 বসে, default-এ বসে না।

এটি দুর্বলতা না সুবিধা? দুটিই। দুর্বলতা, কারণ একটি ভুল interrupt CPU-র কিছু সময় খায়, আর সতর্ক না থাকলে software ভাবে IR7-এর যন্ত্র ডেকেছে। এই পর্বের মডেলে দেখেছেন, spurious-এ bus-এ 47H এসেছে অথচ ISR = 0; যে ISR না দেখে EOI দেয়, সে হয়তো অন্য কোনো level-এর বিট মুছে ফেলে, কারণ non-specific EOI সবচেয়ে উঁচু বিটটি মোছে। সুবিধা, কারণ বিকল্পটি আরও খারাপ: data bus-এ কেউ কিছু না দিলে CPU একটি এলোমেলো byte-কে type হিসেবে পড়ত, আর অজানা জায়গায় লাফ দিত। একটি নির্দিষ্ট, চেনা জায়গায় পাঠানো নিরাপদ ব্যর্থতা।

আধুনিক PC-র চর্চায় “spurious IRQ7” আর slave-এর ক্ষেত্রে “spurious IRQ15” নিয়ে এখনো আলোচনা হয়; OS-এর handler ISR register পড়ে, spurious হলে কোনো EOI না দিয়ে (slave-এর ক্ষেত্রে শুধু master-কে) ফিরে আসে।

মূল উপলব্ধি: Hardware অনিশ্চয়তার মুখে একটি নির্দিষ্ট, চেনা আচরণ বেছে নিলে software সেটি ধরতে পারে; ISR register পড়ে যাচাই না করলে সেই সুবিধা নষ্ট হয়।

প্র ০৫Fully nested, automatic rotation, special mask আর poll — চারটি mode একই chip-এ কেন? একটি বাস্তব যন্ত্রে কখন কোনটি বেছে নেবেন?

চারটি mode আসলে চার রকম ন্যায্যতার নীতি। Fully nested বলে, জরুরি সবসময় আগে, আর চলতি কাজকে কম জরুরি কেউ থামাবে না। এটি বেশিরভাগ যন্ত্রের জন্য স্বাভাবিক পছন্দ, কারণ এখানে অগ্রাধিকার deadline-এর সঙ্গে মেলানো যায় (প্রশ্ন ৩), আর non-specific EOI নিরাপদ। এর ঝুঁকি starvation: একটি ব্যস্ত উঁচু লাইন নিচুদের চিরকাল অপেক্ষায় রাখতে পারে, যা rotate.py-র প্রথম লাইনে দেখেছেন।

Automatic rotation বলে, সবাই সমান; যে এইমাত্র পেয়েছে সে লাইনের শেষে যাক। একই রকম কয়েকটি যন্ত্রের জন্য এটি আদর্শ: বাজারঘরের একাধিক scale, বা একটি communication controller-এর কয়েকটি একই রকম channel. Datasheet-এর নিশ্চয়তা: সবচেয়ে খারাপ ক্ষেত্রে সাতজনের পরে পালা আসবেই। দাম হলো, কোনো লাইনকে আর “জরুরি” বলা যায় না, আর EOI-তে সতর্ক থাকতে হয়।

Special mask mode একটি নির্দিষ্ট পরিস্থিতির যন্ত্র: একটি লম্বা ISR তার কাজের একটি অংশে নিচুদেরও ঢুকতে দিতে চায়, ধরুন ধীর একটি display হালনাগাদের সময় keyboard যেন না আটকায়। এটি fully nested কাঠামোকে ইচ্ছা করে ভাঙে, তাই specific EOI বাধ্যতামূলক, আর কাজ শেষে mode বন্ধ করতে ভুললে পরের সব সিদ্ধান্ত বিভ্রান্ত হয়।

Poll mode বলে, CPU নিজে সময় বেছে নেবে। যখন interrupt-এর অপ্রত্যাশিত থামা সহ্য করা যায় না (একটি সময়-সমালোচনামূলক loop), বা যখন ৬৪-এর বেশি লাইন দরকার, তখন CPU নিজের সুবিধামতো poll word পড়ে, আর 8259 তবু অগ্রাধিকারের কাজটি করে দেয়। Polling-এর সরলতা আর PIC-এর resolver একসঙ্গে।

আধুনিক NVIC-এ (পর্ব ৩০) এই পছন্দগুলো অন্য রূপে বেঁচে আছে: প্রতিটি লাইনের আলাদা অগ্রাধিকার সংখ্যা, preemption আর sub-priority-র ভাগ, আর একটি register যা নির্দিষ্ট মানের নিচের সব interrupt সাময়িক আটকায়, special mask-এর এক রকম আত্মীয়। RTOS-এ (পর্ব ৫৬) একই প্রশ্ন task-এর স্তরে: fixed priority বনাম round robin.

মূল উপলব্ধি: একটি chip-এ চারটি নীতি রাখা মানে নীতির সিদ্ধান্ত software-এর হাতে দেওয়া; ভালো নকশা আগে প্রশ্ন করে “এই যন্ত্রগুলোর মধ্যে ন্যায্যতা কী”, তারপর mode বাছে।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। 8086-এর উত্তরগুলো কোর্সের 8086 runner আর এই পর্বের 8259 মডেলে চালিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — level-triggered, AEOI: একটি 8086 বোর্ডে একটি 8259 (port 0F0H/0F2H) শুধু cold-room alarm শুনবে, IR1-এ, level-triggered, auto-EOI-তে, আর IR0–IR7 যাবে type 50H–57H-এ। ICW আর OCW1-এর byte বের করুন, আর এমন program লিখুন যা vector বসায় আর দুটি alarm-এ দুবার A ছাপে।

    ICW1 = 0001 1011 = 1BH (D4 = 1, LTIM = 1, ADI = 0, SNGL = 1, IC4 = 1); ICW2 = 50H; ICW4 = 0000 0011 = 03H (AEOI = 1, µPM = 1); OCW1 = 1111 1101 = 0FDH. IR1 → type 51H, vector 51H × 4 = 00144H. ISR-এ কোনো EOI নেই, কারণ AEOI দ্বিতীয় INTA̅-এর শেষে বিট মোছে।

            cli
            mov al, 1Bh             ; ICW1
            out 0F0h, al
            mov al, 50h             ; ICW2
            out 0F2h, al
            mov al, 03h             ; ICW4: AEOI, 8086
            out 0F2h, al
            mov al, 0FDh            ; OCW1: only IR1
            out 0F2h, al
            xor ax, ax
            mov es, ax
            mov word [es:51h*4], alarm
            mov [es:51h*4+2], cs
            sti
    idle:   cmp byte [count], 2
            jb idle
            mov ax, 4C00h
            int 21h
    alarm:  push ax                 ; no EOI: AEOI
            push dx
            mov dl, 'A'
            mov ah, 02h
            int 21h
            inc byte [count]
            pop dx
            pop ax
            iret
    count:  db 0

    সত্যিকারের run (run8259.py aeoi86.asm --ir 30:1,4 --ir 60:1; শুরুতে org 100h) দুবার INTR -> 2 x INTA, IR1, type 51h দেখিয়েছে, প্রতিবার ISR=00000000 (AEOI), আর A দুবার; শেষে [exit code 0 via INT 21h/4Ch, 74 instructions]. একটি বাড়তি পর্যবেক্ষণ: একই সময়ে তোলা IR4 সারাক্ষণ IRR-এ (IRR=00010000) বসে ছিল, কারণ mask অনুরোধ মোছে না। Level mode-এর একটি নিয়ম মডেল দেখায় না, কিন্তু বাস্তবে জরুরি: AEOI আর level একসঙ্গে থাকলে ISR-এর IRET-এর আগে যন্ত্রের লাইন নামাতে হবে (ধরুন alarm-এর status পড়ে), না হলে IF = 1 হওয়া মাত্র একই interrupt আবার আসবে।

  2. ভুল খুঁজুন — ঠিক byte, ভুল ঠিকানা: একজন pic86.asm-এর ISR-এর শেষটি এভাবে লিখলেন: mov al, 20h, out 0F2h, al, তারপর inc byte [count] আর iret. বাকি সব এক। তিনটি IR (0, 1, 2) একসঙ্গে উঠলে কী হবে? IMR-এ কী থাকবে?

    Port 0F2H মানে A0 = 1. শুরুর ক্রম শেষ, তাই A0 = 1-এ লেখা যেকোনো byte OCW1: 20H সরাসরি IMR-এ গেল। সত্যিকারের run-এর লগ (wrong86.asm):

    8259| INTR -> 2 x INTA, IR0, type 40h   IRR=00000110 ISR=00000001 IMR=11111000
    U
    8259| OUT F2h <- 20h  OCW1 (IMR)               IRR=00000110 ISR=00000001 IMR=00100000
    [error: stopped after 3000 instructions without INT 21h/4Ch, 2999 instructions]

    দুটি ক্ষতি একসঙ্গে। এক, কোনো EOI যায়নি, তাই ISR-এ IR0-এর বিট বসে রইল, আর IR1, IR2 (নিচু) চিরকাল আটকে গেল; program count 3-এর অপেক্ষায় ঘুরছে। দুই, IMR = 00100000: আগে বন্ধ রাখা IR3, IR4, IR6, IR7 এখন খোলা, শুধু IR5 বন্ধ; কোনো ভাসমান লাইনে noise এলেই অজানা type 43H–47H-এ লাফ। Assembler কোনো ভুল ধরে না, কারণ দুটি port-ই বৈধ। ঠিক রূপ: out 0F0h, al. চেনার কৌশল: EOI, ICW1, OCW3 যায় A0 = 0-এ; শুধু mask আর ICW2–4 A0 = 1-এ।

  3. হিসাব — CALL ঠিকানা আর type: (ক) একটি 8085 বোর্ডে ICW1 = 12H, ICW2 = 30H. IR5 অনুরোধ করলে তিনটি INTA̅-এ data bus-এ কোন তিনটি byte যাবে, আর ISR কোন ঠিকানায়? (খ) ICW1 = 96H হলে একই প্রশ্ন। (গ) একটি 8086 বোর্ডে ICW2 = 0A8H হলে IR5-এর type কত, আর তার vector IVT-র কোন ঠিকানায়?

    (ক) 12H = 0001 0010: ADI = 0 (interval 8), SNGL = 1, IC4 = 0, A7 A6 = 00. নিচু byte = A7 A6 + IR (101) + 000 = 00 101 000 = 28H. Bus-এ CD 28 30, ISR (বা তার JMP) 3028H-এ। (খ) 96H = 1001 0110: A7 A6 A5 = 100, ADI = 1 (interval 4). নিচু byte = 100 101 00 = 94H; bus-এ CD 94 30, ঠিকানা 3094H. (গ) 0A8H = 10101 000; ওপরের পাঁচ বিট রেখে IR5 (101) বসালে type = 10101 101 = ADH. Vector ADH × 4 = 2B4H, অর্থাৎ 002B4H–002B7H. তিনটি উত্তরই পাতার মডেলের inta()-তে চালিয়ে মেলানো: ['0xcd', '0x28', '0x30'], ['0xcd', '0x94', '0x30'], আর 0xad 0x2b4.

  4. আগে বলুন, তারপর চালান — নিচু লাইনের অপেক্ষা: একটি 8086 বোর্ডে 8259 ICW 13H, 40H, 01H আর OCW1 = F8H দিয়ে চালু। Alarm-এর ISR (IR1) EOI দিতে ভুলে গেছে, বাকি দুটি ISR ঠিক আছে। পরপর আসে: alarm, তারপর tare (IR2), তারপর UART (IR0). কোন কোন ISR চলবে, আর শেষে IRR আর ISR কত?

    Alarm চলবে (ISR = 00000010) আর EOI ছাড়াই ফিরবে, বিট রয়ে যাবে। Tare IRR-এ বসবে (00000100), কিন্তু IR2 < IR1 অগ্রাধিকারে, তাই কখনো চলবে না। UART (IR0) উঁচু, তাই চলবে, ISR = 00000011, আর নিজের EOI-তে শুধু IR0 মুছবে। শেষে IRR = 00000100, ISR = 00000010. অংশ ৫-এর সত্যিকারের run (noeoi86.asm) ঠিক এটিই ছেপেছে: A, তারপর U, শেষ লাইনে IRR=00000100 ISR=00000010, আর ৩০০০ নির্দেশের সীমায় থামা। ছাপা অক্ষরের ক্রম A, U; T কখনো আসে না।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রম8086 mode-এর একটি 8259-এ IR1 ওঠার পরের ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. IRR-এর বিট 1 বসে, আর 8259 INT উঁচু করে
  2. CPU চলতি নির্দেশ শেষ করে, IF = 1 দেখে প্রথম INTA̅ দেয়
  3. ISR register-এর বিট 1 বসে, IRR-এর বিট 1 মোছে
  4. দ্বিতীয় INTA̅-এ 8259 data bus-এ type 41H দেয়
  5. CPU FLAGS, CS, IP রেখে IVT-র 00104H থেকে ISR-এ যায়
  6. ISR কাজ শেষে OCW2 = 20H দেয়, তারপর IRET

একটি 8086 system-এ একটিমাত্র 8259, edge-triggered, normal EOI. ICW1-এর সঠিক byte কোনটি?

  • 12H
  • 13H
  • 11H
  • 1BH

8086 mode-এ একটি 8259-এর ICW2 = 40H. IR5 থেকে interrupt এলে CPU কোন type পায়?

  • 40H
  • 54H
  • 05H
  • 45H

8259 fully nested mode-এ, কোনো rotation ছাড়া। ISR register = 00000101 (IR0 আর IR2 সেবায়). Port A0 = 0-এ OCW2 = 20H লিখলে ISR register কত হবে?

  • 00000100
  • 00000001
  • 00000000
  • 00000101

8085 mode-এ একটি interrupt-এর জন্য 8259 কয়টি INTA̅ pulse পায়, আর প্রথমটিতে data bus-এ কী রাখে?

  • দুটি; প্রথমটিতে কিছু না, দ্বিতীয়টিতে type
  • একটি; RST n-এর opcode
  • তিনটি; প্রথমটিতে CALL-এর opcode CDH
  • তিনটি; প্রথমটিতে JMP-এর opcode C3H

8259A-গুলো cascade করে বাড়তি circuit ছাড়া সর্বোচ্চ কতটি interrupt level পাওয়া যায়, আর কীভাবে?

  • ১৫টি, একটি master আর একটি slave
  • ৬৪টি, একটি master আর আটটি slave
  • ৫১২টি, তিন স্তরে
  • ২৫৬টি, চারটি master দিয়ে

একটি 8259-এ (A0 = 0 port 0F0H) কোন কোন level-এর সেবা চলছে তা পড়তে চান। কোন ক্রম ঠিক?

  • in al, 0F2h
  • mov al, 0Ah, out 0F0h, al, in al, 0F0h
  • mov al, 0Ch, out 0F0h, al, in al, 0F0h
  • mov al, 0Bh, out 0F0h, al, in al, 0F0h

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. তিন register: IRR অনুরোধ, ISR register সেবা চলছে, IMR mask; IMR IRR-কে মোছে না। শুরুর নিয়মে IR0 উঁচু, IR7 নিচু।
  2. ICW: ICW1 (A0 = 0, D4 = 1: LTIM, ADI, SNGL, IC4), ICW2 (type বা উঁচু ঠিকানা), ICW3 শুধু cascade-এ, ICW4 (µPM, AEOI, BUF, M/S, SFNM). 8086-এ একটি chip: 13H 40H 01H.
  3. INTA: 8085 mode-এ তিনটি (CDH, নিচু, উঁচু byte); 8086 mode-এ দুটি, দ্বিতীয়টিতে type = ICW2-এর T7–T3 + IR.
  4. OCW: OCW1 = IMR; OCW2-এ EOI (20H non-specific, 60H + L specific, A0H rotate, C0H + L set priority); OCW3-এ 0AH/0BH দিয়ে IRR/ISR পড়া, 0CH poll, 68H special mask.
  5. Cascade: master-এর ICW3-এ slave-এর বিট, slave-এর ICW3-এ ID; CAS0–CAS2; ৬৪ level পর্যন্ত; EOI দুটি chip-কেই।

পরের পর্বে: পর্ব ২৭ (8251 USART আর 8237 DMA controller). এই পর্বের UART-এর IR0-এর পেছনের chip কীভাবে একটি byte-কে start, data আর stop বিটে সাজায়, আর 8237 কীভাবে CPU-কে সরিয়ে HOLD/HLDA দিয়ে নিজেই data সরায়।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান