Initial commit
This commit is contained in:
19atlas
commit
b1c90b1ed7
|
|
@ -0,0 +1,6 @@
|
|||
bin/
|
||||
*.o
|
||||
*.out
|
||||
i386-bin/
|
||||
Mkfile.old
|
||||
.vscode/
|
||||
|
|
@ -0,0 +1,674 @@
|
|||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 3, 29 June 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The GNU General Public License is a free, copyleft license for
|
||||
software and other kinds of works.
|
||||
|
||||
The licenses for most software and other practical works are designed
|
||||
to take away your freedom to share and change the works. By contrast,
|
||||
the GNU General Public License is intended to guarantee your freedom to
|
||||
share and change all versions of a program--to make sure it remains free
|
||||
software for all its users. We, the Free Software Foundation, use the
|
||||
GNU General Public License for most of our software; it applies also to
|
||||
any other work released this way by its authors. You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
them if you wish), that you receive source code or can get it if you
|
||||
want it, that you can change the software or use pieces of it in new
|
||||
free programs, and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to prevent others from denying you
|
||||
these rights or asking you to surrender the rights. Therefore, you have
|
||||
certain responsibilities if you distribute copies of the software, or if
|
||||
you modify it: responsibilities to respect the freedom of others.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must pass on to the recipients the same
|
||||
freedoms that you received. You must make sure that they, too, receive
|
||||
or can get the source code. And you must show them these terms so they
|
||||
know their rights.
|
||||
|
||||
Developers that use the GNU GPL protect your rights with two steps:
|
||||
(1) assert copyright on the software, and (2) offer you this License
|
||||
giving you legal permission to copy, distribute and/or modify it.
|
||||
|
||||
For the developers' and authors' protection, the GPL clearly explains
|
||||
that there is no warranty for this free software. For both users' and
|
||||
authors' sake, the GPL requires that modified versions be marked as
|
||||
changed, so that their problems will not be attributed erroneously to
|
||||
authors of previous versions.
|
||||
|
||||
Some devices are designed to deny users access to install or run
|
||||
modified versions of the software inside them, although the manufacturer
|
||||
can do so. This is fundamentally incompatible with the aim of
|
||||
protecting users' freedom to change the software. The systematic
|
||||
pattern of such abuse occurs in the area of products for individuals to
|
||||
use, which is precisely where it is most unacceptable. Therefore, we
|
||||
have designed this version of the GPL to prohibit the practice for those
|
||||
products. If such problems arise substantially in other domains, we
|
||||
stand ready to extend this provision to those domains in future versions
|
||||
of the GPL, as needed to protect the freedom of users.
|
||||
|
||||
Finally, every program is threatened constantly by software patents.
|
||||
States should not allow patents to restrict development and use of
|
||||
software on general-purpose computers, but in those that do, we wish to
|
||||
avoid the special danger that patents applied to a free program could
|
||||
make it effectively proprietary. To prevent this, the GPL assures that
|
||||
patents cannot be used to render the program non-free.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
TERMS AND CONDITIONS
|
||||
|
||||
0. Definitions.
|
||||
|
||||
"This License" refers to version 3 of the GNU General Public License.
|
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds of
|
||||
works, such as semiconductor masks.
|
||||
|
||||
"The Program" refers to any copyrightable work licensed under this
|
||||
License. Each licensee is addressed as "you". "Licensees" and
|
||||
"recipients" may be individuals or organizations.
|
||||
|
||||
To "modify" a work means to copy from or adapt all or part of the work
|
||||
in a fashion requiring copyright permission, other than the making of an
|
||||
exact copy. The resulting work is called a "modified version" of the
|
||||
earlier work or a work "based on" the earlier work.
|
||||
|
||||
A "covered work" means either the unmodified Program or a work based
|
||||
on the Program.
|
||||
|
||||
To "propagate" a work means to do anything with it that, without
|
||||
permission, would make you directly or secondarily liable for
|
||||
infringement under applicable copyright law, except executing it on a
|
||||
computer or modifying a private copy. Propagation includes copying,
|
||||
distribution (with or without modification), making available to the
|
||||
public, and in some countries other activities as well.
|
||||
|
||||
To "convey" a work means any kind of propagation that enables other
|
||||
parties to make or receive copies. Mere interaction with a user through
|
||||
a computer network, with no transfer of a copy, is not conveying.
|
||||
|
||||
An interactive user interface displays "Appropriate Legal Notices"
|
||||
to the extent that it includes a convenient and prominently visible
|
||||
feature that (1) displays an appropriate copyright notice, and (2)
|
||||
tells the user that there is no warranty for the work (except to the
|
||||
extent that warranties are provided), that licensees may convey the
|
||||
work under this License, and how to view a copy of this License. If
|
||||
the interface presents a list of user commands or options, such as a
|
||||
menu, a prominent item in the list meets this criterion.
|
||||
|
||||
1. Source Code.
|
||||
|
||||
The "source code" for a work means the preferred form of the work
|
||||
for making modifications to it. "Object code" means any non-source
|
||||
form of a work.
|
||||
|
||||
A "Standard Interface" means an interface that either is an official
|
||||
standard defined by a recognized standards body, or, in the case of
|
||||
interfaces specified for a particular programming language, one that
|
||||
is widely used among developers working in that language.
|
||||
|
||||
The "System Libraries" of an executable work include anything, other
|
||||
than the work as a whole, that (a) is included in the normal form of
|
||||
packaging a Major Component, but which is not part of that Major
|
||||
Component, and (b) serves only to enable use of the work with that
|
||||
Major Component, or to implement a Standard Interface for which an
|
||||
implementation is available to the public in source code form. A
|
||||
"Major Component", in this context, means a major essential component
|
||||
(kernel, window system, and so on) of the specific operating system
|
||||
(if any) on which the executable work runs, or a compiler used to
|
||||
produce the work, or an object code interpreter used to run it.
|
||||
|
||||
The "Corresponding Source" for a work in object code form means all
|
||||
the source code needed to generate, install, and (for an executable
|
||||
work) run the object code and to modify the work, including scripts to
|
||||
control those activities. However, it does not include the work's
|
||||
System Libraries, or general-purpose tools or generally available free
|
||||
programs which are used unmodified in performing those activities but
|
||||
which are not part of the work. For example, Corresponding Source
|
||||
includes interface definition files associated with source files for
|
||||
the work, and the source code for shared libraries and dynamically
|
||||
linked subprograms that the work is specifically designed to require,
|
||||
such as by intimate data communication or control flow between those
|
||||
subprograms and other parts of the work.
|
||||
|
||||
The Corresponding Source need not include anything that users
|
||||
can regenerate automatically from other parts of the Corresponding
|
||||
Source.
|
||||
|
||||
The Corresponding Source for a work in source code form is that
|
||||
same work.
|
||||
|
||||
2. Basic Permissions.
|
||||
|
||||
All rights granted under this License are granted for the term of
|
||||
copyright on the Program, and are irrevocable provided the stated
|
||||
conditions are met. This License explicitly affirms your unlimited
|
||||
permission to run the unmodified Program. The output from running a
|
||||
covered work is covered by this License only if the output, given its
|
||||
content, constitutes a covered work. This License acknowledges your
|
||||
rights of fair use or other equivalent, as provided by copyright law.
|
||||
|
||||
You may make, run and propagate covered works that you do not
|
||||
convey, without conditions so long as your license otherwise remains
|
||||
in force. You may convey covered works to others for the sole purpose
|
||||
of having them make modifications exclusively for you, or provide you
|
||||
with facilities for running those works, provided that you comply with
|
||||
the terms of this License in conveying all material for which you do
|
||||
not control copyright. Those thus making or running the covered works
|
||||
for you must do so exclusively on your behalf, under your direction
|
||||
and control, on terms that prohibit them from making any copies of
|
||||
your copyrighted material outside their relationship with you.
|
||||
|
||||
Conveying under any other circumstances is permitted solely under
|
||||
the conditions stated below. Sublicensing is not allowed; section 10
|
||||
makes it unnecessary.
|
||||
|
||||
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
|
||||
|
||||
No covered work shall be deemed part of an effective technological
|
||||
measure under any applicable law fulfilling obligations under article
|
||||
11 of the WIPO copyright treaty adopted on 20 December 1996, or
|
||||
similar laws prohibiting or restricting circumvention of such
|
||||
measures.
|
||||
|
||||
When you convey a covered work, you waive any legal power to forbid
|
||||
circumvention of technological measures to the extent such circumvention
|
||||
is effected by exercising rights under this License with respect to
|
||||
the covered work, and you disclaim any intention to limit operation or
|
||||
modification of the work as a means of enforcing, against the work's
|
||||
users, your or third parties' legal rights to forbid circumvention of
|
||||
technological measures.
|
||||
|
||||
4. Conveying Verbatim Copies.
|
||||
|
||||
You may convey verbatim copies of the Program's source code as you
|
||||
receive it, in any medium, provided that you conspicuously and
|
||||
appropriately publish on each copy an appropriate copyright notice;
|
||||
keep intact all notices stating that this License and any
|
||||
non-permissive terms added in accord with section 7 apply to the code;
|
||||
keep intact all notices of the absence of any warranty; and give all
|
||||
recipients a copy of this License along with the Program.
|
||||
|
||||
You may charge any price or no price for each copy that you convey,
|
||||
and you may offer support or warranty protection for a fee.
|
||||
|
||||
5. Conveying Modified Source Versions.
|
||||
|
||||
You may convey a work based on the Program, or the modifications to
|
||||
produce it from the Program, in the form of source code under the
|
||||
terms of section 4, provided that you also meet all of these conditions:
|
||||
|
||||
a) The work must carry prominent notices stating that you modified
|
||||
it, and giving a relevant date.
|
||||
|
||||
b) The work must carry prominent notices stating that it is
|
||||
released under this License and any conditions added under section
|
||||
7. This requirement modifies the requirement in section 4 to
|
||||
"keep intact all notices".
|
||||
|
||||
c) You must license the entire work, as a whole, under this
|
||||
License to anyone who comes into possession of a copy. This
|
||||
License will therefore apply, along with any applicable section 7
|
||||
additional terms, to the whole of the work, and all its parts,
|
||||
regardless of how they are packaged. This License gives no
|
||||
permission to license the work in any other way, but it does not
|
||||
invalidate such permission if you have separately received it.
|
||||
|
||||
d) If the work has interactive user interfaces, each must display
|
||||
Appropriate Legal Notices; however, if the Program has interactive
|
||||
interfaces that do not display Appropriate Legal Notices, your
|
||||
work need not make them do so.
|
||||
|
||||
A compilation of a covered work with other separate and independent
|
||||
works, which are not by their nature extensions of the covered work,
|
||||
and which are not combined with it such as to form a larger program,
|
||||
in or on a volume of a storage or distribution medium, is called an
|
||||
"aggregate" if the compilation and its resulting copyright are not
|
||||
used to limit the access or legal rights of the compilation's users
|
||||
beyond what the individual works permit. Inclusion of a covered work
|
||||
in an aggregate does not cause this License to apply to the other
|
||||
parts of the aggregate.
|
||||
|
||||
6. Conveying Non-Source Forms.
|
||||
|
||||
You may convey a covered work in object code form under the terms
|
||||
of sections 4 and 5, provided that you also convey the
|
||||
machine-readable Corresponding Source under the terms of this License,
|
||||
in one of these ways:
|
||||
|
||||
a) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by the
|
||||
Corresponding Source fixed on a durable physical medium
|
||||
customarily used for software interchange.
|
||||
|
||||
b) Convey the object code in, or embodied in, a physical product
|
||||
(including a physical distribution medium), accompanied by a
|
||||
written offer, valid for at least three years and valid for as
|
||||
long as you offer spare parts or customer support for that product
|
||||
model, to give anyone who possesses the object code either (1) a
|
||||
copy of the Corresponding Source for all the software in the
|
||||
product that is covered by this License, on a durable physical
|
||||
medium customarily used for software interchange, for a price no
|
||||
more than your reasonable cost of physically performing this
|
||||
conveying of source, or (2) access to copy the
|
||||
Corresponding Source from a network server at no charge.
|
||||
|
||||
c) Convey individual copies of the object code with a copy of the
|
||||
written offer to provide the Corresponding Source. This
|
||||
alternative is allowed only occasionally and noncommercially, and
|
||||
only if you received the object code with such an offer, in accord
|
||||
with subsection 6b.
|
||||
|
||||
d) Convey the object code by offering access from a designated
|
||||
place (gratis or for a charge), and offer equivalent access to the
|
||||
Corresponding Source in the same way through the same place at no
|
||||
further charge. You need not require recipients to copy the
|
||||
Corresponding Source along with the object code. If the place to
|
||||
copy the object code is a network server, the Corresponding Source
|
||||
may be on a different server (operated by you or a third party)
|
||||
that supports equivalent copying facilities, provided you maintain
|
||||
clear directions next to the object code saying where to find the
|
||||
Corresponding Source. Regardless of what server hosts the
|
||||
Corresponding Source, you remain obligated to ensure that it is
|
||||
available for as long as needed to satisfy these requirements.
|
||||
|
||||
e) Convey the object code using peer-to-peer transmission, provided
|
||||
you inform other peers where the object code and Corresponding
|
||||
Source of the work are being offered to the general public at no
|
||||
charge under subsection 6d.
|
||||
|
||||
A separable portion of the object code, whose source code is excluded
|
||||
from the Corresponding Source as a System Library, need not be
|
||||
included in conveying the object code work.
|
||||
|
||||
A "User Product" is either (1) a "consumer product", which means any
|
||||
tangible personal property which is normally used for personal, family,
|
||||
or household purposes, or (2) anything designed or sold for incorporation
|
||||
into a dwelling. In determining whether a product is a consumer product,
|
||||
doubtful cases shall be resolved in favor of coverage. For a particular
|
||||
product received by a particular user, "normally used" refers to a
|
||||
typical or common use of that class of product, regardless of the status
|
||||
of the particular user or of the way in which the particular user
|
||||
actually uses, or expects or is expected to use, the product. A product
|
||||
is a consumer product regardless of whether the product has substantial
|
||||
commercial, industrial or non-consumer uses, unless such uses represent
|
||||
the only significant mode of use of the product.
|
||||
|
||||
"Installation Information" for a User Product means any methods,
|
||||
procedures, authorization keys, or other information required to install
|
||||
and execute modified versions of a covered work in that User Product from
|
||||
a modified version of its Corresponding Source. The information must
|
||||
suffice to ensure that the continued functioning of the modified object
|
||||
code is in no case prevented or interfered with solely because
|
||||
modification has been made.
|
||||
|
||||
If you convey an object code work under this section in, or with, or
|
||||
specifically for use in, a User Product, and the conveying occurs as
|
||||
part of a transaction in which the right of possession and use of the
|
||||
User Product is transferred to the recipient in perpetuity or for a
|
||||
fixed term (regardless of how the transaction is characterized), the
|
||||
Corresponding Source conveyed under this section must be accompanied
|
||||
by the Installation Information. But this requirement does not apply
|
||||
if neither you nor any third party retains the ability to install
|
||||
modified object code on the User Product (for example, the work has
|
||||
been installed in ROM).
|
||||
|
||||
The requirement to provide Installation Information does not include a
|
||||
requirement to continue to provide support service, warranty, or updates
|
||||
for a work that has been modified or installed by the recipient, or for
|
||||
the User Product in which it has been modified or installed. Access to a
|
||||
network may be denied when the modification itself materially and
|
||||
adversely affects the operation of the network or violates the rules and
|
||||
protocols for communication across the network.
|
||||
|
||||
Corresponding Source conveyed, and Installation Information provided,
|
||||
in accord with this section must be in a format that is publicly
|
||||
documented (and with an implementation available to the public in
|
||||
source code form), and must require no special password or key for
|
||||
unpacking, reading or copying.
|
||||
|
||||
7. Additional Terms.
|
||||
|
||||
"Additional permissions" are terms that supplement the terms of this
|
||||
License by making exceptions from one or more of its conditions.
|
||||
Additional permissions that are applicable to the entire Program shall
|
||||
be treated as though they were included in this License, to the extent
|
||||
that they are valid under applicable law. If additional permissions
|
||||
apply only to part of the Program, that part may be used separately
|
||||
under those permissions, but the entire Program remains governed by
|
||||
this License without regard to the additional permissions.
|
||||
|
||||
When you convey a copy of a covered work, you may at your option
|
||||
remove any additional permissions from that copy, or from any part of
|
||||
it. (Additional permissions may be written to require their own
|
||||
removal in certain cases when you modify the work.) You may place
|
||||
additional permissions on material, added by you to a covered work,
|
||||
for which you have or can give appropriate copyright permission.
|
||||
|
||||
Notwithstanding any other provision of this License, for material you
|
||||
add to a covered work, you may (if authorized by the copyright holders of
|
||||
that material) supplement the terms of this License with terms:
|
||||
|
||||
a) Disclaiming warranty or limiting liability differently from the
|
||||
terms of sections 15 and 16 of this License; or
|
||||
|
||||
b) Requiring preservation of specified reasonable legal notices or
|
||||
author attributions in that material or in the Appropriate Legal
|
||||
Notices displayed by works containing it; or
|
||||
|
||||
c) Prohibiting misrepresentation of the origin of that material, or
|
||||
requiring that modified versions of such material be marked in
|
||||
reasonable ways as different from the original version; or
|
||||
|
||||
d) Limiting the use for publicity purposes of names of licensors or
|
||||
authors of the material; or
|
||||
|
||||
e) Declining to grant rights under trademark law for use of some
|
||||
trade names, trademarks, or service marks; or
|
||||
|
||||
f) Requiring indemnification of licensors and authors of that
|
||||
material by anyone who conveys the material (or modified versions of
|
||||
it) with contractual assumptions of liability to the recipient, for
|
||||
any liability that these contractual assumptions directly impose on
|
||||
those licensors and authors.
|
||||
|
||||
All other non-permissive additional terms are considered "further
|
||||
restrictions" within the meaning of section 10. If the Program as you
|
||||
received it, or any part of it, contains a notice stating that it is
|
||||
governed by this License along with a term that is a further
|
||||
restriction, you may remove that term. If a license document contains
|
||||
a further restriction but permits relicensing or conveying under this
|
||||
License, you may add to a covered work material governed by the terms
|
||||
of that license document, provided that the further restriction does
|
||||
not survive such relicensing or conveying.
|
||||
|
||||
If you add terms to a covered work in accord with this section, you
|
||||
must place, in the relevant source files, a statement of the
|
||||
additional terms that apply to those files, or a notice indicating
|
||||
where to find the applicable terms.
|
||||
|
||||
Additional terms, permissive or non-permissive, may be stated in the
|
||||
form of a separately written license, or stated as exceptions;
|
||||
the above requirements apply either way.
|
||||
|
||||
8. Termination.
|
||||
|
||||
You may not propagate or modify a covered work except as expressly
|
||||
provided under this License. Any attempt otherwise to propagate or
|
||||
modify it is void, and will automatically terminate your rights under
|
||||
this License (including any patent licenses granted under the third
|
||||
paragraph of section 11).
|
||||
|
||||
However, if you cease all violation of this License, then your
|
||||
license from a particular copyright holder is reinstated (a)
|
||||
provisionally, unless and until the copyright holder explicitly and
|
||||
finally terminates your license, and (b) permanently, if the copyright
|
||||
holder fails to notify you of the violation by some reasonable means
|
||||
prior to 60 days after the cessation.
|
||||
|
||||
Moreover, your license from a particular copyright holder is
|
||||
reinstated permanently if the copyright holder notifies you of the
|
||||
violation by some reasonable means, this is the first time you have
|
||||
received notice of violation of this License (for any work) from that
|
||||
copyright holder, and you cure the violation prior to 30 days after
|
||||
your receipt of the notice.
|
||||
|
||||
Termination of your rights under this section does not terminate the
|
||||
licenses of parties who have received copies or rights from you under
|
||||
this License. If your rights have been terminated and not permanently
|
||||
reinstated, you do not qualify to receive new licenses for the same
|
||||
material under section 10.
|
||||
|
||||
9. Acceptance Not Required for Having Copies.
|
||||
|
||||
You are not required to accept this License in order to receive or
|
||||
run a copy of the Program. Ancillary propagation of a covered work
|
||||
occurring solely as a consequence of using peer-to-peer transmission
|
||||
to receive a copy likewise does not require acceptance. However,
|
||||
nothing other than this License grants you permission to propagate or
|
||||
modify any covered work. These actions infringe copyright if you do
|
||||
not accept this License. Therefore, by modifying or propagating a
|
||||
covered work, you indicate your acceptance of this License to do so.
|
||||
|
||||
10. Automatic Licensing of Downstream Recipients.
|
||||
|
||||
Each time you convey a covered work, the recipient automatically
|
||||
receives a license from the original licensors, to run, modify and
|
||||
propagate that work, subject to this License. You are not responsible
|
||||
for enforcing compliance by third parties with this License.
|
||||
|
||||
An "entity transaction" is a transaction transferring control of an
|
||||
organization, or substantially all assets of one, or subdividing an
|
||||
organization, or merging organizations. If propagation of a covered
|
||||
work results from an entity transaction, each party to that
|
||||
transaction who receives a copy of the work also receives whatever
|
||||
licenses to the work the party's predecessor in interest had or could
|
||||
give under the previous paragraph, plus a right to possession of the
|
||||
Corresponding Source of the work from the predecessor in interest, if
|
||||
the predecessor has it or can get it with reasonable efforts.
|
||||
|
||||
You may not impose any further restrictions on the exercise of the
|
||||
rights granted or affirmed under this License. For example, you may
|
||||
not impose a license fee, royalty, or other charge for exercise of
|
||||
rights granted under this License, and you may not initiate litigation
|
||||
(including a cross-claim or counterclaim in a lawsuit) alleging that
|
||||
any patent claim is infringed by making, using, selling, offering for
|
||||
sale, or importing the Program or any portion of it.
|
||||
|
||||
11. Patents.
|
||||
|
||||
A "contributor" is a copyright holder who authorizes use under this
|
||||
License of the Program or a work on which the Program is based. The
|
||||
work thus licensed is called the contributor's "contributor version".
|
||||
|
||||
A contributor's "essential patent claims" are all patent claims
|
||||
owned or controlled by the contributor, whether already acquired or
|
||||
hereafter acquired, that would be infringed by some manner, permitted
|
||||
by this License, of making, using, or selling its contributor version,
|
||||
but do not include claims that would be infringed only as a
|
||||
consequence of further modification of the contributor version. For
|
||||
purposes of this definition, "control" includes the right to grant
|
||||
patent sublicenses in a manner consistent with the requirements of
|
||||
this License.
|
||||
|
||||
Each contributor grants you a non-exclusive, worldwide, royalty-free
|
||||
patent license under the contributor's essential patent claims, to
|
||||
make, use, sell, offer for sale, import and otherwise run, modify and
|
||||
propagate the contents of its contributor version.
|
||||
|
||||
In the following three paragraphs, a "patent license" is any express
|
||||
agreement or commitment, however denominated, not to enforce a patent
|
||||
(such as an express permission to practice a patent or covenant not to
|
||||
sue for patent infringement). To "grant" such a patent license to a
|
||||
party means to make such an agreement or commitment not to enforce a
|
||||
patent against the party.
|
||||
|
||||
If you convey a covered work, knowingly relying on a patent license,
|
||||
and the Corresponding Source of the work is not available for anyone
|
||||
to copy, free of charge and under the terms of this License, through a
|
||||
publicly available network server or other readily accessible means,
|
||||
then you must either (1) cause the Corresponding Source to be so
|
||||
available, or (2) arrange to deprive yourself of the benefit of the
|
||||
patent license for this particular work, or (3) arrange, in a manner
|
||||
consistent with the requirements of this License, to extend the patent
|
||||
license to downstream recipients. "Knowingly relying" means you have
|
||||
actual knowledge that, but for the patent license, your conveying the
|
||||
covered work in a country, or your recipient's use of the covered work
|
||||
in a country, would infringe one or more identifiable patents in that
|
||||
country that you have reason to believe are valid.
|
||||
|
||||
If, pursuant to or in connection with a single transaction or
|
||||
arrangement, you convey, or propagate by procuring conveyance of, a
|
||||
covered work, and grant a patent license to some of the parties
|
||||
receiving the covered work authorizing them to use, propagate, modify
|
||||
or convey a specific copy of the covered work, then the patent license
|
||||
you grant is automatically extended to all recipients of the covered
|
||||
work and works based on it.
|
||||
|
||||
A patent license is "discriminatory" if it does not include within
|
||||
the scope of its coverage, prohibits the exercise of, or is
|
||||
conditioned on the non-exercise of one or more of the rights that are
|
||||
specifically granted under this License. You may not convey a covered
|
||||
work if you are a party to an arrangement with a third party that is
|
||||
in the business of distributing software, under which you make payment
|
||||
to the third party based on the extent of your activity of conveying
|
||||
the work, and under which the third party grants, to any of the
|
||||
parties who would receive the covered work from you, a discriminatory
|
||||
patent license (a) in connection with copies of the covered work
|
||||
conveyed by you (or copies made from those copies), or (b) primarily
|
||||
for and in connection with specific products or compilations that
|
||||
contain the covered work, unless you entered into that arrangement,
|
||||
or that patent license was granted, prior to 28 March 2007.
|
||||
|
||||
Nothing in this License shall be construed as excluding or limiting
|
||||
any implied license or other defenses to infringement that may
|
||||
otherwise be available to you under applicable patent law.
|
||||
|
||||
12. No Surrender of Others' Freedom.
|
||||
|
||||
If conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot convey a
|
||||
covered work so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you may
|
||||
not convey it at all. For example, if you agree to terms that obligate you
|
||||
to collect a royalty for further conveying from those to whom you convey
|
||||
the Program, the only way you could satisfy both those terms and this
|
||||
License would be to refrain entirely from conveying the Program.
|
||||
|
||||
13. Use with the GNU Affero General Public License.
|
||||
|
||||
Notwithstanding any other provision of this License, you have
|
||||
permission to link or combine any covered work with a work licensed
|
||||
under version 3 of the GNU Affero General Public License into a single
|
||||
combined work, and to convey the resulting work. The terms of this
|
||||
License will continue to apply to the part which is the covered work,
|
||||
but the special requirements of the GNU Affero General Public License,
|
||||
section 13, concerning interaction through a network will apply to the
|
||||
combination as such.
|
||||
|
||||
14. Revised Versions of this License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions of
|
||||
the GNU General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the
|
||||
Program specifies that a certain numbered version of the GNU General
|
||||
Public License "or any later version" applies to it, you have the
|
||||
option of following the terms and conditions either of that numbered
|
||||
version or of any later version published by the Free Software
|
||||
Foundation. If the Program does not specify a version number of the
|
||||
GNU General Public License, you may choose any version ever published
|
||||
by the Free Software Foundation.
|
||||
|
||||
If the Program specifies that a proxy can decide which future
|
||||
versions of the GNU General Public License can be used, that proxy's
|
||||
public statement of acceptance of a version permanently authorizes you
|
||||
to choose that version for the Program.
|
||||
|
||||
Later license versions may give you additional or different
|
||||
permissions. However, no additional obligations are imposed on any
|
||||
author or copyright holder as a result of your choosing to follow a
|
||||
later version.
|
||||
|
||||
15. Disclaimer of Warranty.
|
||||
|
||||
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
|
||||
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
|
||||
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
|
||||
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
|
||||
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
|
||||
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
|
||||
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. Limitation of Liability.
|
||||
|
||||
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
|
||||
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
|
||||
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
|
||||
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
|
||||
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
|
||||
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
|
||||
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGES.
|
||||
|
||||
17. Interpretation of Sections 15 and 16.
|
||||
|
||||
If the disclaimer of warranty and limitation of liability provided
|
||||
above cannot be given local legal effect according to their terms,
|
||||
reviewing courts shall apply local law that most closely approximates
|
||||
an absolute waiver of all civil liability in connection with the
|
||||
Program, unless a warranty or assumption of liability accompanies a
|
||||
copy of the Program in return for a fee.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
state the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program does terminal interaction, make it output a short
|
||||
notice like this when it starts in an interactive mode:
|
||||
|
||||
<program> Copyright (C) <year> <name of author>
|
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, your program's commands
|
||||
might be different; for a GUI interface, you would use an "about box".
|
||||
|
||||
You should also get your employer (if you work as a programmer) or school,
|
||||
if any, to sign a "copyright disclaimer" for the program, if necessary.
|
||||
For more information on this, and how to apply and follow the GNU GPL, see
|
||||
<https://www.gnu.org/licenses/>.
|
||||
|
||||
The GNU General Public License does not permit incorporating your program
|
||||
into proprietary programs. If your program is a subroutine library, you
|
||||
may consider it more useful to permit linking proprietary applications with
|
||||
the library. If this is what you want to do, use the GNU Lesser General
|
||||
Public License instead of this License. But first, please read
|
||||
<https://www.gnu.org/licenses/why-not-lgpl.html>.
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#elfgcc=tools/i386-elf/bin/i386-elf-gcc # installation from toolchain dir
|
||||
#elfld=tools/i386-elf/bin/i386-elf-ld
|
||||
|
||||
elfgcc=i386-elf-gcc # installation from `yay -S i386-elf-gcc`
|
||||
elfld=i386-elf-ld
|
||||
|
||||
BUILD_DIR=i386-bin
|
||||
|
||||
.PHONY: build
|
||||
build: $(clean)
|
||||
export PATH=$PATH:/usr/local/i386elfgcc/bin
|
||||
mkdir -pv $(BUILD_DIR)
|
||||
@printf "\n\e[0;32m==> $(BUILD_DIR) e derleniyor..."
|
||||
@nasm "src/bootloader/stage1/stage1.asm" -f bin -o "$(BUILD_DIR)/stage1.bin"
|
||||
@nasm "src/bootloader/stage2/stage2.asm" -f elf -o "$(BUILD_DIR)/stage2.o"
|
||||
@nasm "src/kernel/kernel.asm" -f elf -o "$(BUILD_DIR)/kernel_asm.o"
|
||||
@nasm "src/kernel/modules.asm" -f elf -o "$(BUILD_DIR)/moduleAsm.o"
|
||||
$(elfgcc) -ffreestanding -m32 -g -c -Wno-write-strings "src/bootloader/stage2/bootloader.cpp" -o "$(BUILD_DIR)/bootloader.o"
|
||||
$(elfgcc) -ffreestanding -m32 -g -c -Wno-write-strings "src/kernel/kernel.cpp" -o "$(BUILD_DIR)/kernel_c.o"
|
||||
$(elfgcc) -ffreestanding -m32 -g -c -Wno-write-strings "src/kernel/modules.cpp" -o "$(BUILD_DIR)/modulesC.o"
|
||||
$(elfld) -o "$(BUILD_DIR)/bootloader.bin" -T i386-bootloader.ld "$(BUILD_DIR)/stage2.o" "$(BUILD_DIR)/bootloader.o" --oformat binary
|
||||
$(elfld) -o "$(BUILD_DIR)/kernel.bin" -T i386-kernel.ld "$(BUILD_DIR)/kernel_asm.o" "$(BUILD_DIR)/kernel_c.o" --oformat binary
|
||||
$(elfld) -o "$(BUILD_DIR)/modules.bin" -T i386-module.ld "$(BUILD_DIR)/moduleAsm.o" "$(BUILD_DIR)/modulesC.o" --oformat binary
|
||||
cat "$(BUILD_DIR)/stage1.bin" "$(BUILD_DIR)/bootloader.bin" > "$(BUILD_DIR)/boot.bin"
|
||||
dd if=/dev/zero of=$(BUILD_DIR)/disk.bin bs=512 count=2880
|
||||
mkfs.fat -v -F 12 -n "DISK" $(BUILD_DIR)/disk.bin #kernel and module outputs are on disk
|
||||
dd if=$(BUILD_DIR)/boot.bin of=$(BUILD_DIR)/disk.bin conv=notrunc
|
||||
@mcopy -v -i $(BUILD_DIR)/disk.bin $(BUILD_DIR)/kernel.bin "::kernel.bin"
|
||||
@mcopy -v -i $(BUILD_DIR)/disk.bin $(BUILD_DIR)/modules.bin "::modules.bin"
|
||||
|
||||
.PHONY: help
|
||||
help:
|
||||
@printf "clean: derlenmişi temizler\nbuild: derler\nrun: qemu da açar\noutput: $(BUILD_DIR)"
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
rm -rvf $(BUILD_DIR)/*
|
||||
.PHONY: setup
|
||||
setup:
|
||||
./tools/toolchain
|
||||
|
||||
.PHONY: run
|
||||
run:
|
||||
qemu-system-i386 -m 256M -device VGA,vgamem_mb=128 $(BUILD_DIR)/disk.bin
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
# vimixOS
|
||||
i386 mimarili minimal işletim sistemi. (gerçi işletim sistemi denilebilirse)
|
||||
<br>[for english version](https://github.com/19atlas/vimixos/blob/main/README_EN.md)
|
||||
## Derlemek için,
|
||||
### küçük not: Fedora, Gentoo, Debian tabanlı ve Arch tabanlı sistemlerde denenmiştir.
|
||||
- `make setup` komutuyla derleyici kurulacaktır.
|
||||
- kurulduğunda `make clean build` komutunu çalıştırın.
|
||||
|
||||
## Sıra çalıştırmada!
|
||||
- öncelikle gereken paketleri kurmalısınız <br>`nasm`<br>`qemu-full`<br>`qemu-headless-arch-extra`<br> paketleri gibi [daha fazla bilgi için](https://github.com/nanobyte-dev/nanobyte_os#building)
|
||||
- `make run` komutu ile qemuyu açın.
|
||||
|
||||
## Vimixos hedefleri:
|
||||
- [ ] stabilite (cidden zor)
|
||||
- [ ] uygun bir shell
|
||||
- [ ] çok uzun zaman sonra uygulama geliştirme (DEler yazma programları vs.)
|
||||
- [ ] internet
|
||||
- [ ] akıllı saatlere portlama (imkansız)
|
||||
|
||||
## eklenmesi gerekenler:
|
||||
- [ ] FAT32 destegi
|
||||
- [ ] C++ desteği
|
||||
- [ ] UNIX-like
|
||||
- [ ] SHELL
|
||||
|
||||
## Vimixos dizinleri
|
||||
- `i386-bin` vimixos derlendikten sonra çıktıyı buraya atar
|
||||
- `src` vimixos kaynağı
|
||||
- `src/kernel` viniz kerneli burda bulunur
|
||||
- `src/bootloader` vimixos bootloader
|
||||
- `tools/toolchain` çalıştırılabilir dosyası vimixos'a uygun binutils ve derleyiciyi indirir.
|
||||
|
||||
BU PROJE GPL LİSANSI İLE LİSANSLANMIŞTIR [daha fazla bilgi için](https://www.gnu.org/licenses/rms-why-gplv3.html)
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# vimixOS
|
||||
Minimal operating system with i386 architecture. (if it can even be called an operating system)
|
||||
## For compiling
|
||||
### footnote: tested in: Fedora, Gentoo, Debian and Arch based distros
|
||||
- `make setup` The toolchains will be compiled with the command
|
||||
- when finished run `make clean build`!
|
||||
|
||||
## Emulation (QEMU)
|
||||
- You should install required packages, such as <br>`qemu-full`<br>`qemu-headless-arch-extra` packages [for more information](https://github.com/nanobyte-dev/nanobyte_os#building)
|
||||
- run `make run` for qemu
|
||||
|
||||
## Vimixos goals:
|
||||
- [ ] stability (serius)
|
||||
- [ ] shell (but minimal for some reasons)
|
||||
- [ ] UI (ex. GUI)
|
||||
- [ ] internet
|
||||
- [ ] porting to smartwatch (impossible)
|
||||
|
||||
## Features to be added
|
||||
- [ ] FAT32 support
|
||||
- [ ] file system (from scratch)
|
||||
- [ ] C++ and compiler support
|
||||
- [ ] UNIX-like
|
||||
- [ ] SHELL
|
||||
|
||||
## Vimixos file locations
|
||||
- `i386-bin` vimixos after compiled files
|
||||
- `src/kernel` viniz kernel
|
||||
- `src/bootloader` vimixos bootloader
|
||||
- `tools/toolchain` file for vimixos'a suitable binutils and cross-compiler.
|
||||
|
||||
this project under the GPL LICENSE [see](https://www.gnu.org/licenses/rms-why-gplv3.html)
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
ENTRY(bootloader)
|
||||
OUTPUT_FORMAT("binary")
|
||||
phys = 0x00001000;
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
. = phys;
|
||||
|
||||
.text : { __text_start = .; *(.text) }
|
||||
.data : { __data_start = .; *(.data) }
|
||||
.rodata : { __rodata_start = .; *(.rodata) }
|
||||
.bss : { __bss_start = .; *(.bss) }
|
||||
|
||||
__end = .;
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
ENTRY(main)
|
||||
OUTPUT_FORMAT("binary")
|
||||
phys = 0x0100000;
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
. = phys;
|
||||
|
||||
.text : { __text_start = .; *(.text) }
|
||||
.data : { __data_start = .; *(.data) }
|
||||
.rodata : { __rodata_start = .; *(.rodata) }
|
||||
.bss : { __bss_start = .; *(.bss) }
|
||||
|
||||
__end = .;
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
ENTRY(main)
|
||||
OUTPUT_FORMAT("binary")
|
||||
phys = 0x150000;
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
. = phys;
|
||||
|
||||
.text : { __text_start = .; *(.text) }
|
||||
.data : { __data_start = .; *(.data) }
|
||||
.rodata : { __rodata_start = .; *(.rodata) }
|
||||
.bss : { __bss_start = .; *(.bss) }
|
||||
|
||||
__end = .;
|
||||
}
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
;function of reading from disk.
|
||||
disk_read:
|
||||
;read data from the disk with the given parameters at the specified memory address.
|
||||
mov ah, 0x02 ;function for reading from disk.
|
||||
mov ch, 0x00 ;disk cylinder number.
|
||||
mov dh, 0x00 ;disk head number.
|
||||
push 0x0000 ;es contains the memory segment.
|
||||
pop es
|
||||
;calls switch 0x13 to read from disk with given parameters.
|
||||
int 0x13
|
||||
;on a successful read the ah register equals zero.
|
||||
cmp ah, 0x00
|
||||
;if not, jump to the disk_read_error label.
|
||||
jne disk_read_error
|
||||
;returns to where the disk_read function was called.
|
||||
ret
|
||||
|
||||
;if unsuccessful print error
|
||||
disk_read_error:
|
||||
call hataYaz
|
||||
hlt
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
;https://wiki.osdev.org/Global_Descriptor_Table
|
||||
gdt_start:
|
||||
|
||||
gdt_null:
|
||||
|
||||
DD 0x00000000
|
||||
DD 0x00000000
|
||||
|
||||
gdt_code:
|
||||
|
||||
DW 0xFFFF
|
||||
DW 0x0000
|
||||
DB 0x00
|
||||
DB 0x9A
|
||||
DB 0xCF
|
||||
DB 0x00
|
||||
|
||||
gdt_data:
|
||||
|
||||
DW 0xFFFF
|
||||
DW 0x0000
|
||||
DB 0x00
|
||||
DB 0x92
|
||||
DB 0xCF
|
||||
DB 0x00
|
||||
|
||||
gdt_end:
|
||||
|
||||
gdt_descriptor:
|
||||
|
||||
DW gdt_end - gdt_start - 1
|
||||
DD gdt_start
|
||||
|
||||
CODE_SEG EQU gdt_code - gdt_start
|
||||
DATA_SEG EQU gdt_data - gdt_start
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
hataYaz:
|
||||
mov ebx, 0xb8000 ;Video Memory
|
||||
mov si, HataMsg ; load the address of the message into si
|
||||
jmp .print
|
||||
.print:
|
||||
mov ah, 0x0e ; set the video function to write a character with attribute
|
||||
mov bh, 0x00 ; page number
|
||||
mov bl, 0x07 ; attribute (white text on black background)
|
||||
.next_char:
|
||||
lodsb ; load the next character from si al = next chracter
|
||||
cmp al, 0 ; check if we have reached the end of the string
|
||||
je .finish ; if so, jump to finish
|
||||
int 0x10 ; otherwise, write the character to the screen
|
||||
jmp .next_char
|
||||
.finish:
|
||||
hlt
|
||||
jmp $
|
||||
|
||||
HataMsg: db "VIMIZ DISK HATASI",0x0D, 0x0a,"disk okunamiyor...", 0
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
;function to enter protected mode.
|
||||
enter_protected:
|
||||
cli ;disable the switches.
|
||||
lgdt[gdt_descriptor] ;loads the global description table.
|
||||
;enter protected mode.
|
||||
mov eax, cr0
|
||||
or eax, 0x00000001
|
||||
mov cr0, eax
|
||||
ret ;returns to where the function was called.
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
[ORG 0x7C00]
|
||||
[BITS 16]
|
||||
|
||||
;the boot manager memory address.
|
||||
BOOTLOADER_ADDRESS EQU 0x1000
|
||||
|
||||
;jump short to the _bootloader
|
||||
jmp short _bootloader
|
||||
nop
|
||||
|
||||
;SIEB parameter block.
|
||||
BPB_OEM: db 'VIMIZ OS'
|
||||
BPB_BYTES_PER_SECTOR: dw 0x0200
|
||||
BPB_SECTORS_PER_CLUSTER: db 0x01
|
||||
BPB_RESERVED_SECTORS: dw 0x000A
|
||||
BPB_FAT_NUMBER: db 0x02
|
||||
BPB_DIR_ENTRIES_NUMBER: dw 0x00E0
|
||||
BPB_TOTAL_SECTORS: dw 0x0B40
|
||||
BPB_MEDIA_DESCRIPTOR_TYPE: db 0xF0
|
||||
BPB_SECTORS_PER_FAT: dw 0x0009
|
||||
BPB_SECTORS_PER_TRACK: dw 0x0012
|
||||
BPB_HEAD_NUMBER: dw 0x0002
|
||||
BPB_HIDDEN_SECTORS: dd 0x00000000
|
||||
BPB_LARGE_SECTOR_NUMBER: dd 0x00000000
|
||||
|
||||
;extended boot track.
|
||||
EBR_DRIVE_NUMBER: db 0x00
|
||||
EBR_RESERVED: db 0x00
|
||||
EBR_SIGNATURE: db 0x29
|
||||
EBR_VOLUME_ID: db 0x11, 0x11, 0x11, 0x11
|
||||
EBR_VOLUME_LABEL: db 'DISK '
|
||||
EBR_SYSTEM_ID: db 'FAT12 '
|
||||
|
||||
_bootloader:
|
||||
|
||||
;move the boot disk number to EBR_DRIVE_NUMBER
|
||||
mov [EBR_DRIVE_NUMBER], dl
|
||||
|
||||
;clear the screen by resetting the graphics mode.
|
||||
mov ah, 0x00 ;function for switching the graphics mode.
|
||||
mov al, 0x03 ;graphics mode 0x03 text 80x25 characters.
|
||||
int 0x10 ;call the 0x10 switch to reset the graphics mode.
|
||||
|
||||
;loads the next sector at memory address 0x7E00.
|
||||
;sets the parameters for the read from disk function.
|
||||
mov al, 0x01 ;number of sectors to read.
|
||||
mov bx, 0x7E00 ;memory address where to load the data.
|
||||
mov cl, 0x02 ;sector number to start from.
|
||||
|
||||
call disk_read ;calls the read from disk function.
|
||||
|
||||
jmp _bootloader16 ;jump to the _bootloader16
|
||||
|
||||
%INCLUDE"src/bootloader/stage1/include/disk.asm"
|
||||
%INCLUDE"src/bootloader/stage1/include/gdt.asm"
|
||||
%INCLUDE"src/bootloader/stage1/include/protected_mode.asm"
|
||||
%INCLUDE"src/bootloader/stage1/include/hata.asm" ;for error screen
|
||||
|
||||
;fill the rest of the sector excluding the last two octets with 0s.
|
||||
TIMES 510-($-$$) DB 0x00
|
||||
;the last two octets must be 0x55 and 0xAA for the disk to be bootable.
|
||||
DW 0xAA55
|
||||
|
||||
_bootloader16:
|
||||
;sets segment registers.
|
||||
cli ;disable the switches.
|
||||
mov ax, 0x0000
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov ss, ax
|
||||
mov sp, 0x7C00
|
||||
sti ;re-enable the switches.
|
||||
|
||||
;loads the boot manager at the memory address specified above.
|
||||
;sets the parameters for the read from disk function.
|
||||
mov al, 0x20 ;number of sectors to read.
|
||||
mov bx, BOOTLOADER_ADDRESS ;memory address where to load the data.
|
||||
mov cl, 0x03 ;sector number to start from.
|
||||
|
||||
call disk_read ;calls the read from disk function.
|
||||
|
||||
call enter_protected ;enter protected mode.
|
||||
|
||||
jmp CODE_SEG:_bootloader32 ;jump to the _bootloader32 label.
|
||||
|
||||
[BITS 32]
|
||||
_bootloader32:
|
||||
mov ax, DATA_SEG
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov fs, ax
|
||||
mov gs, ax
|
||||
mov ss, ax
|
||||
|
||||
;enable line A20 to use all available memory.
|
||||
in al, 0x92
|
||||
or al, 0x02
|
||||
out 0x92, al
|
||||
|
||||
;sets up the boot manager and operating system stack.
|
||||
mov ebp, 0x10000
|
||||
mov esp, ebp
|
||||
|
||||
;jump to boot manager memory address.
|
||||
jmp BOOTLOADER_ADDRESS
|
||||
|
||||
;fill the rest of the sector with 0.
|
||||
TIMES 1024-($-$$) DB 0x00
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#include"include/initialize.h"
|
||||
#include"include/stdio.h"
|
||||
#include"include/ata.h"
|
||||
#include"include/fs.h"
|
||||
#include"include/fat12.h"
|
||||
|
||||
//bootloader main global function.
|
||||
extern "C" void bootloader() {
|
||||
//initialize the components.
|
||||
initialize();
|
||||
//read the data kernel.bin ie the core of the operating system.
|
||||
fread("KERNEL BIN", 0x0100000);
|
||||
//jump to the address where the kernel was loaded and run it.
|
||||
void(*kernel)(void) = (void(*)())0x0100000;
|
||||
kernel();
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#pragma once
|
||||
|
||||
#include"ports.h"
|
||||
#include<stdint.h>
|
||||
|
||||
#define STATUS_BUSY 0x80
|
||||
#define STATUS_READY 0x40
|
||||
#define STATUS_DRQ 0x08
|
||||
#define STATUS_DF 0x20
|
||||
#define STATUS_ERR 0x01
|
||||
|
||||
static void ATA_wait_BSY() {
|
||||
while(inb(0x01F7) & STATUS_BUSY);
|
||||
}
|
||||
|
||||
static void ATA_wait_DRQ() {
|
||||
while(!inb(0x01F7) & STATUS_READY);
|
||||
}
|
||||
|
||||
//disk reading function.
|
||||
void read_sectors(uint32_t address, uint32_t lba, uint8_t sector_count) {
|
||||
//wait for the disk to be ready and free to read.
|
||||
ATA_wait_BSY();
|
||||
//set the reading parameters.
|
||||
outb(0x01F6, 0xE0 | ((lba >> 0x18) & 0x0F));
|
||||
outb(0x01F2, sector_count);
|
||||
outb(0x01F3, (uint8_t)lba);
|
||||
outb(0x01F4, (uint8_t)(lba >> 8));
|
||||
outb(0x01F5, (uint8_t)(lba >> 16));
|
||||
//sends the read signal.
|
||||
outb(0x01F7, 0x20);
|
||||
uint16_t* target = (uint16_t*)address;
|
||||
for(uint32_t i = 0x00; i < sector_count; i++) {
|
||||
ATA_wait_BSY();
|
||||
ATA_wait_DRQ();
|
||||
for(uint32_t j = 0x00; j < 0x0100; j++)
|
||||
//copy data to MAC memory.
|
||||
target[j] = inw(0x01F0);
|
||||
target += 0x0100;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
//disk writing
|
||||
void write_sectors(uint32_t lba, uint8_t sector_count, uint32_t* bytes) {
|
||||
//wait for the disk to be ready and free to read.
|
||||
ATA_wait_BSY();
|
||||
//set the reading parameters.
|
||||
outb(0x01F6, 0xE0 | ((lba >> 0x18) & 0x0F));
|
||||
outb(0x01F2, sector_count);
|
||||
outb(0x01F3, (uint8_t)lba);
|
||||
outb(0x01F4, (uint8_t)(lba >> 8));
|
||||
outb(0x01F5, (uint8_t)(lba >> 16));
|
||||
//sends write signal.
|
||||
outb(0x01F7, 0x30);
|
||||
for(uint32_t i = 0x00; i < sector_count; i++) {
|
||||
ATA_wait_BSY();
|
||||
ATA_wait_DRQ();
|
||||
for(uint32_t j = 0x00; j < 0x0100; j++)
|
||||
//copy the data to the storage device.
|
||||
outd(0x01F0, bytes[i]);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#pragma once
|
||||
|
||||
#include"fs.h"
|
||||
#include<stdint.h>
|
||||
#include<stdbool.h>
|
||||
|
||||
//data entry structure.
|
||||
struct file_entry {
|
||||
//data name.
|
||||
uint8_t name[11];
|
||||
//attributes.
|
||||
uint8_t attributes;
|
||||
//reserved.
|
||||
uint8_t reserved;
|
||||
//creation date.
|
||||
uint8_t created_time_tenths;
|
||||
uint16_t created_time;
|
||||
uint16_t created_date;
|
||||
//last access date.
|
||||
uint16_t accessed_time;
|
||||
//first group upper part.
|
||||
uint16_t first_cluster_high;
|
||||
//date of last modification.
|
||||
uint16_t modified_time;
|
||||
uint16_t modified_date;
|
||||
//lower first group.
|
||||
uint16_t first_cluster_low;
|
||||
//data size.
|
||||
uint32_t size;
|
||||
} __attribute((packed));
|
||||
|
||||
//reads data from disk to the specified memory address.
|
||||
bool fread(const char* filename, uint32_t address) {
|
||||
file_entry* file;
|
||||
char* mem = (char*)0x30000;
|
||||
while ((char*)mem < (char*)0x50000) {
|
||||
if(compare_strings(filename, mem)==true) {
|
||||
file = (file_entry*)mem;
|
||||
break;
|
||||
}
|
||||
mem+=32;
|
||||
}
|
||||
//if the counter has arrived at the address 0x00050000 it means that the entry has not been found.
|
||||
if((uint8_t*)mem == (uint8_t*)0x00050000)
|
||||
return false;
|
||||
//calculates the block of logical address.
|
||||
uint32_t lba = ((bpb->BPB_RESERVED_SECTORS + bpb->BPB_FAT_NUMBER * bpb->BPB_SECTORS_PER_FAT + (bpb->BPB_DIR_ENTRIES_NUMBER * 32 + bpb-> BPB_BYTES_PER_SECTOR -1) / bpb->BPB_BYTES_PER_SECTOR)) + (file->first_cluster_low - 2) * bpb-> BPB_SECTORS_PER_CLUSTER;
|
||||
//read the sectors containing the requested data.
|
||||
read_sectors(address, lba, (file->size / bpb->BPB_BYTES_PER_SECTOR + 1));
|
||||
return true;
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#pragma once
|
||||
|
||||
#include"stdio.h"
|
||||
#include"string.h"
|
||||
#include"ata.h"
|
||||
#include<stdint.h>
|
||||
|
||||
//structure of the parameter block of the SIEB.
|
||||
struct bios_parameter_block {
|
||||
//short jump and nop.
|
||||
uint8_t NOP[0x03];
|
||||
//codice del produttore di apparecchiature originali.
|
||||
uint8_t BPB_OEM[0x08];
|
||||
//numero di octeti per settore.
|
||||
uint16_t BPB_BYTES_PER_SECTOR;
|
||||
//numero di settori per gruppo.
|
||||
uint8_t BPB_SECTORS_PER_CLUSTER;
|
||||
//numero di settori riservati.
|
||||
uint16_t BPB_RESERVED_SECTORS;
|
||||
//numero di tavole di allocazione dei dati.
|
||||
uint8_t BPB_FAT_NUMBER;
|
||||
//numero di entrate nel percorso radice.
|
||||
uint16_t BPB_DIR_ENTRIES_NUMBER;
|
||||
//numero di settori totale.
|
||||
uint16_t BPB_TOTAL_SECTORS;
|
||||
//codice del tipo di dispositivo di memoria.
|
||||
uint8_t BPB_MEDIA_DESCRIPTOR_TYPE;
|
||||
//numero di settori per tavola di allocazione dei dati.
|
||||
uint16_t BPB_SECTORS_PER_FAT;
|
||||
//numero di settori per traccia.
|
||||
uint16_t BPB_SECTORS_PER_TRACK;
|
||||
//numero di testine.
|
||||
uint16_t BPB_HEAD_NUMBER;
|
||||
//numero di settori nascosti.
|
||||
uint32_t BPB_HIDDEN_SECTORS;
|
||||
//numero di settori larghi.
|
||||
uint32_t BPB_LARGE_SECTOR_NUMBER;
|
||||
} __attribute((packed));
|
||||
|
||||
//struttura della traccia d'avvio estesa.
|
||||
struct extended_boot_record {
|
||||
//numero di identificazione del dispositivo di memoria.
|
||||
uint8_t EBR_DRIVE_NUMBER;
|
||||
//riservato.
|
||||
uint8_t EBR_RESERVED;
|
||||
//firma.
|
||||
uint8_t EBR_SIGNATURE;
|
||||
//numero di identificazione del volume.
|
||||
uint32_t EBR_VOLUME_ID;
|
||||
//nome del volume.
|
||||
uint8_t EBR_VOLUME_LABEL[0x0B];
|
||||
//stringa di identificazione del tipo di struttura del disco.
|
||||
uint8_t EBR_SYSTEM_ID;
|
||||
} __attribute((packed));
|
||||
|
||||
//dichiara un puntatore alla struttura del blocco dei parametri del SIEB.
|
||||
bios_parameter_block* bpb;
|
||||
//dichiara un puntatore alla struttura della traccia d'avvio estesa.
|
||||
extended_boot_record* ebr;
|
||||
|
||||
//funzione della lettura della tavola di allocazione dei dati.
|
||||
void read_fat() {
|
||||
//leggi la tavola di allocazione dei dati.
|
||||
read_sectors(0x20000, bpb->BPB_RESERVED_SECTORS, bpb->BPB_FAT_NUMBER * bpb->BPB_SECTORS_PER_FAT);
|
||||
return;
|
||||
}
|
||||
|
||||
//funzione della lettura del percorso radice.
|
||||
void read_root_dir() {
|
||||
//leggi il percorso radice.
|
||||
read_sectors(0x30000, bpb->BPB_RESERVED_SECTORS + bpb->BPB_FAT_NUMBER * bpb->BPB_SECTORS_PER_FAT,
|
||||
(bpb->BPB_DIR_ENTRIES_NUMBER * 32 + bpb-> BPB_BYTES_PER_SECTOR -1) / bpb->BPB_BYTES_PER_SECTOR);
|
||||
return;
|
||||
}
|
||||
|
||||
//funzione di inizializzazione della struttura del disco.
|
||||
void initialize_fs() {
|
||||
bpb = (bios_parameter_block*)0x00007C00;
|
||||
ebr = (extended_boot_record*)0x00007C24;
|
||||
read_fat();
|
||||
read_root_dir();
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
#pragma once
|
||||
|
||||
#include"stdio.h"
|
||||
#include"fs.h"
|
||||
|
||||
//init
|
||||
void initialize() {
|
||||
initialize_fs();
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#pragma once
|
||||
|
||||
#include<stdint.h>
|
||||
|
||||
//output function of an octet to an input and output port.
|
||||
static inline void outb(uint16_t port, uint8_t value) {
|
||||
asm("outb %0, %1" : : "a"(value), "Nd"(port));
|
||||
return;
|
||||
}
|
||||
|
||||
//input function of an octet to an input and output port.
|
||||
static inline uint8_t inb(uint16_t port) {
|
||||
uint8_t value;
|
||||
asm("inb %1, %0" : "=a"(value) : "Nd"(port));
|
||||
return value;
|
||||
}
|
||||
|
||||
//output function of two octets to one input and output port.
|
||||
static inline void outw(uint16_t port, uint16_t value) {
|
||||
asm("out %%ax, %%dx" : : "a"(value), "d"(port));
|
||||
return;
|
||||
}
|
||||
|
||||
//input function of two octets to an input and output port.
|
||||
static inline uint16_t inw(uint16_t port) {
|
||||
uint16_t value;
|
||||
asm("in %%dx, %%ax" : "=a"(value) : "d"(port));
|
||||
return value;
|
||||
}
|
||||
|
||||
//output function of four octets to one input and output port.
|
||||
static inline void outd(uint32_t port, uint32_t value) {
|
||||
asm("outl %%eax, %%dx" : : "a"(value), "d"(port));
|
||||
}
|
||||
|
||||
//input function of four octets to an input and output port.
|
||||
static inline uint32_t ind(uint32_t port) {
|
||||
uint32_t value;
|
||||
asm("inl %%dx, %%eax" : "=a"(value) : "d"(port));
|
||||
return value;
|
||||
}
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
#pragma once
|
||||
|
||||
#include"string.h"
|
||||
#include"ports.h"
|
||||
#include<stdint.h>
|
||||
#include<stdarg.h>
|
||||
|
||||
//imleç konumu.
|
||||
uint16_t x_pos = 0x0000, y_pos = 0x0000;
|
||||
//metin rengi.
|
||||
uint8_t color = 0x07;
|
||||
//metin arka plan rengi.
|
||||
uint8_t bg_color = 0x00;
|
||||
|
||||
//metin modu bellek adresi 0x03.
|
||||
uint32_t* video_memory = (uint32_t*)0x000B8000;
|
||||
|
||||
//metnin rengini ayarlayın.
|
||||
void set_color(uint8_t new_color) {
|
||||
color = new_color;
|
||||
return;
|
||||
}
|
||||
|
||||
//metnin arka plan rengini ayarlar.
|
||||
void set_bg_color(uint8_t new_color) {
|
||||
bg_color = new_color;
|
||||
return;
|
||||
}
|
||||
|
||||
//metni bir satır aşağı kaydırır.
|
||||
void scroll() {
|
||||
uint8_t attribute = (0x00 << 0x04) | (0x0F & 0x0F);
|
||||
uint16_t blank = 0x0020 | (attribute << 0x0008);
|
||||
if(y_pos >= 0x0019) {
|
||||
for(uint32_t i = 0x00000000 * 0x00000050; i < 0x00000018 * 0x00000050; i++)
|
||||
video_memory[i] = video_memory[i + 0x00000050];
|
||||
for(uint32_t i = 0x00000018 * 0x00000050; i < 0x00000019 * 0x00000050; i++)
|
||||
video_memory[i] = blank;
|
||||
y_pos = 0x0018;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
//imlecin ekrandaki konumunu günceller.
|
||||
void update_cursor_pos(uint16_t x, uint16_t y) {
|
||||
uint16_t cursor_pos = y * 0x0050 + x;
|
||||
outb(0x03D4, 0x0F);
|
||||
outb(0x03D5, (uint8_t)(cursor_pos & 0xFF));
|
||||
outb(0x03D4, 0x0E);
|
||||
outb(0x03D5, (uint8_t)((cursor_pos >> 0x08) & 0xFF));
|
||||
return;
|
||||
}
|
||||
|
||||
//imleç konumunu ilerleterek ekrana bir karakter yazar.
|
||||
void putc(unsigned char c){
|
||||
uint16_t attrib = (0 << 4) | (color & 0x0F);
|
||||
volatile uint16_t* where;
|
||||
where = (volatile uint16_t *)0xB8000 + (y_pos * 80 + x_pos);
|
||||
*where = c | (attrib << 8);
|
||||
if(++x_pos >= 80){
|
||||
x_pos = 0;
|
||||
y_pos++;
|
||||
}
|
||||
update_cursor_pos(x_pos, y_pos);
|
||||
if(y_pos >= 25) {
|
||||
x_pos = 0;
|
||||
scroll();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
//imleci geri hareket ettirerek ekrandaki bir karakteri kaldırır.
|
||||
void putcback(){
|
||||
uint16_t attrib = (0 << 4) | (color & 0x0F);
|
||||
volatile uint16_t * where;
|
||||
x_pos--;
|
||||
if(x_pos < 0) {
|
||||
x_pos = 79;
|
||||
y_pos--;
|
||||
}
|
||||
where = (volatile uint16_t *)0xB8000 + (y_pos * 80 + x_pos);
|
||||
*where = ' ' | (attrib << 8);
|
||||
update_cursor_pos(x_pos, y_pos);
|
||||
if(y_pos >= 25) {
|
||||
x_pos = 0;
|
||||
scroll();
|
||||
}
|
||||
}
|
||||
|
||||
//imleç konumunu ilerleterek ekrana bir dizi yazar.
|
||||
void puts(char* string){
|
||||
uint16_t i;
|
||||
while(*string){
|
||||
switch(*string){
|
||||
case 0x0A:
|
||||
x_pos = 0x0000;
|
||||
y_pos++;
|
||||
*string++;
|
||||
scroll();
|
||||
break;
|
||||
case 0x09:
|
||||
for(i = 0x0000; i <= 0x0008; i++) {
|
||||
putc(' ');
|
||||
}
|
||||
*string++;
|
||||
break;
|
||||
default:
|
||||
putc(*string);
|
||||
*string++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
update_cursor_pos(x_pos, y_pos);
|
||||
return;
|
||||
}
|
||||
|
||||
//imleç konumunu ilerleterek ekrana zengin bir dize yazar.
|
||||
void printf(char* format, ...) {
|
||||
va_list ap;
|
||||
va_start(ap, format);
|
||||
char* pointer;
|
||||
for (pointer = format; *pointer != 0x00; pointer++) {
|
||||
if (*pointer == '%') {
|
||||
++pointer;
|
||||
switch (*pointer) {
|
||||
case 0x63:
|
||||
putc(va_arg(ap, int));
|
||||
break;
|
||||
case 0x73:
|
||||
puts(va_arg(ap, char*));
|
||||
break;
|
||||
case 0x64:
|
||||
puts(int_to_string(va_arg(ap, int), 10));
|
||||
break;
|
||||
case 0x78:
|
||||
puts(int_to_string(va_arg(ap, uint32_t), 16));
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
putc(*pointer);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#pragma once
|
||||
|
||||
#include<stdint.h>
|
||||
#include<stdbool.h>
|
||||
|
||||
//bir sayıyı bir diziye dönüştürür.
|
||||
char* int_to_string(unsigned int num, int base) {
|
||||
static char repr[]= "0123456789ABCDEF";
|
||||
static char buffer[50];
|
||||
char *ptr;
|
||||
|
||||
ptr = &buffer[49];
|
||||
*ptr = '\0';
|
||||
|
||||
do {
|
||||
*--ptr = repr[num%base];
|
||||
num /= base;
|
||||
}while(num != 0);
|
||||
|
||||
return(ptr);
|
||||
}
|
||||
|
||||
//iki diziyi karşılaştırın.
|
||||
bool compare_strings(const char* string1, const char* string2) {
|
||||
while(*string1!=0) {
|
||||
if(*string1 != *string2)
|
||||
return false;
|
||||
string1++;
|
||||
string2++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
[BITS 32]
|
||||
;import the bootloader function from bootloader.cpp.
|
||||
[EXTERN bootloader]
|
||||
;call the bootloader function.
|
||||
call bootloader
|
||||
;creates an infinite loop by jumping to the current memory address.
|
||||
jmp $
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#pragma once
|
||||
|
||||
#include"ports.h"
|
||||
#include<stdint.h>
|
||||
|
||||
#define STATUS_BUSY 0x80
|
||||
#define STATUS_READY 0x40
|
||||
#define STATUS_DRQ 0x08
|
||||
#define STATUS_DF 0x20
|
||||
#define STATUS_ERR 0x01
|
||||
|
||||
static void ATA_wait_BSY() {
|
||||
while(inb(0x01F7) & STATUS_BUSY);
|
||||
}
|
||||
|
||||
static void ATA_wait_DRQ() {
|
||||
while(!inb(0x01F7) & STATUS_READY);
|
||||
}
|
||||
|
||||
//disk reading function.
|
||||
void read_sectors(uint32_t address, uint32_t lba, uint8_t sector_count) {
|
||||
//wait for the disk to be ready and free to read.
|
||||
ATA_wait_BSY();
|
||||
//set the reading parameters.
|
||||
outb(0x01F6, 0xE0 | ((lba >> 0x18) & 0x0F));
|
||||
outb(0x01F2, sector_count);
|
||||
outb(0x01F3, (uint8_t)lba);
|
||||
outb(0x01F4, (uint8_t)(lba >> 8));
|
||||
outb(0x01F5, (uint8_t)(lba >> 16));
|
||||
//sends the read signal.
|
||||
outb(0x01F7, 0x20);
|
||||
uint16_t* target = (uint16_t*)address;
|
||||
for(uint32_t i = 0x00; i < sector_count; i++) {
|
||||
ATA_wait_BSY();
|
||||
ATA_wait_DRQ();
|
||||
for(uint32_t j = 0x00; j < 0x0100; j++)
|
||||
//copy data to MAC memory.
|
||||
target[j] = inw(0x01F0);
|
||||
target += 0x0100;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
//disk writing function.
|
||||
void write_sectors(uint32_t lba, uint8_t sector_count, uint32_t* bytes) {
|
||||
//wait for the disk to be ready and free to read.
|
||||
ATA_wait_BSY();
|
||||
//set the reading parameters.
|
||||
outb(0x01F6, 0xE0 | ((lba >> 0x18) & 0x0F));
|
||||
outb(0x01F2, sector_count);
|
||||
outb(0x01F3, (uint8_t)lba);
|
||||
outb(0x01F4, (uint8_t)(lba >> 8));
|
||||
outb(0x01F5, (uint8_t)(lba >> 16));
|
||||
//invia il segnale di scrittura.
|
||||
outb(0x01F7, 0x30);
|
||||
for(uint32_t i = 0x00; i < sector_count; i++) {
|
||||
ATA_wait_BSY();
|
||||
ATA_wait_DRQ();
|
||||
for(uint32_t j = 0x00; j < 0x0100; j++)
|
||||
//copy the data to the storage device.
|
||||
outd(0x01F0, bytes[i]);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,203 @@
|
|||
#pragma once
|
||||
|
||||
#include"memory.h"
|
||||
#include"ports.h"
|
||||
#include<stddef.h>
|
||||
#include<stdint.h>
|
||||
|
||||
//global description table entry structure.
|
||||
struct gdt_entry_t {
|
||||
uint16_t limit_low;
|
||||
uint16_t base_low;
|
||||
uint8_t base_middle;
|
||||
uint8_t access;
|
||||
uint8_t granularity;
|
||||
uint8_t base_high;
|
||||
}__attribute__((packed));
|
||||
|
||||
//pointer structure of the global description table.
|
||||
struct gdt_ptr_t {
|
||||
uint16_t limit;
|
||||
uint32_t base;
|
||||
}__attribute__((packed));
|
||||
|
||||
//switches description table entry structure.
|
||||
struct idt_entry_t {
|
||||
uint16_t base_low;
|
||||
uint16_t kernel_cs;
|
||||
uint8_t zero;
|
||||
uint8_t flags;
|
||||
uint16_t base_high;
|
||||
}__attribute__((packed));
|
||||
|
||||
//pointer structure of the switch description table.
|
||||
struct idt_ptr_t {
|
||||
uint16_t limit;
|
||||
uint32_t base;
|
||||
}__attribute__((packed));
|
||||
|
||||
//declaration of the global variables of the description tables.
|
||||
gdt_entry_t gdt_entries[5];
|
||||
gdt_ptr_t gdt_ptr;
|
||||
idt_entry_t idt_entries[256];
|
||||
idt_ptr_t idt_ptr;
|
||||
|
||||
//global description table unload function.
|
||||
extern "C" void gdt_flush(uint32_t);
|
||||
|
||||
//function of setting the gates of the global description table.
|
||||
static void gdt_set_gate(int num, uint32_t base, uint32_t limit, uint8_t access, uint8_t gran){
|
||||
gdt_entries[num].base_low = (base & 0xFFFF);
|
||||
gdt_entries[num].base_middle = (base >> 16) & 0xFF;
|
||||
gdt_entries[num].base_high = (base >> 24) & 0xFF;
|
||||
gdt_entries[num].limit_low = (limit & 0xFFFF);
|
||||
gdt_entries[num].granularity = (limit >> 16) & 0x0F;
|
||||
gdt_entries[num].granularity |= gran & 0xF0;
|
||||
gdt_entries[num].access = access;
|
||||
}
|
||||
|
||||
//global description table initialization function.
|
||||
static void initialize_gdt(){
|
||||
gdt_ptr.limit = (sizeof(gdt_entry_t) * 5) - 1;
|
||||
gdt_ptr.base = (uint32_t)&gdt_entries;
|
||||
gdt_set_gate(0, 0, 0, 0, 0);
|
||||
gdt_set_gate(1, 0, 0xFFFFFFFF, 0x9A, 0xCF);
|
||||
gdt_set_gate(2, 0, 0xFFFFFFFF, 0x92, 0xCF);
|
||||
gdt_set_gate(3, 0, 0xFFFFFFFF, 0xFA, 0xCF);
|
||||
gdt_set_gate(4, 0, 0xFFFFFFFF, 0xF2, 0xCF);
|
||||
gdt_flush((uint32_t)&gdt_ptr);
|
||||
}
|
||||
|
||||
//switch service managers.
|
||||
extern "C" void isr0();
|
||||
extern "C" void isr1();
|
||||
extern "C" void isr2();
|
||||
extern "C" void isr3();
|
||||
extern "C" void isr4();
|
||||
extern "C" void isr5();
|
||||
extern "C" void isr6();
|
||||
extern "C" void isr7();
|
||||
extern "C" void isr8();
|
||||
extern "C" void isr9();
|
||||
extern "C" void isr10();
|
||||
extern "C" void isr11();
|
||||
extern "C" void isr12();
|
||||
extern "C" void isr13();
|
||||
extern "C" void isr14();
|
||||
extern "C" void isr15();
|
||||
extern "C" void isr16();
|
||||
extern "C" void isr17();
|
||||
extern "C" void isr18();
|
||||
extern "C" void isr19();
|
||||
extern "C" void isr20();
|
||||
extern "C" void isr21();
|
||||
extern "C" void isr22();
|
||||
extern "C" void isr23();
|
||||
extern "C" void isr24();
|
||||
extern "C" void isr25();
|
||||
extern "C" void isr26();
|
||||
extern "C" void isr27();
|
||||
extern "C" void isr28();
|
||||
extern "C" void isr29();
|
||||
extern "C" void isr30();
|
||||
extern "C" void isr31();
|
||||
extern "C" void irq0();
|
||||
extern "C" void irq1();
|
||||
extern "C" void irq2();
|
||||
extern "C" void irq3();
|
||||
extern "C" void irq4();
|
||||
extern "C" void irq5();
|
||||
extern "C" void irq6();
|
||||
extern "C" void irq7();
|
||||
extern "C" void irq8();
|
||||
extern "C" void irq9();
|
||||
extern "C" void irq10();
|
||||
extern "C" void irq11();
|
||||
extern "C" void irq12();
|
||||
extern "C" void irq13();
|
||||
extern "C" void irq14();
|
||||
extern "C" void irq15();
|
||||
|
||||
//download function of the switch description table.
|
||||
extern "C" void idt_flush(uint32_t);
|
||||
|
||||
//switch description table gate setting function.
|
||||
static void idt_set_gate(uint8_t num, uint32_t base, uint16_t sel, uint8_t flags){
|
||||
idt_entries[num].base_low = base & 0xFFFF;
|
||||
idt_entries[num].base_high = (base >> 16) & 0xFFFF;
|
||||
idt_entries[num].kernel_cs = sel;
|
||||
idt_entries[num].zero = 0;
|
||||
idt_entries[num].flags = flags;
|
||||
}
|
||||
|
||||
//switch description table gate setting function.
|
||||
static void initialize_idt(){
|
||||
idt_ptr.limit = sizeof(idt_entry_t) * 256 - 1;
|
||||
idt_ptr.base = (uint32_t)&idt_entries;
|
||||
memset(&idt_entries, 0, sizeof(idt_entry_t)*256);
|
||||
outb(0x20, 0x11);
|
||||
outb(0xA0, 0x11);
|
||||
outb(0x21, 0x20);
|
||||
outb(0xA1, 0x28);
|
||||
outb(0x21, 0x04);
|
||||
outb(0xA1, 0x02);
|
||||
outb(0x21, 0x01);
|
||||
outb(0xA1, 0x01);
|
||||
outb(0x21, 0x0);
|
||||
outb(0xA1, 0x0);
|
||||
idt_set_gate(0, (uint32_t)isr0 , 0x08, 0x8E);
|
||||
idt_set_gate(1, (uint32_t)isr1 , 0x08, 0x8E);
|
||||
idt_set_gate(2, (uint32_t)isr2 , 0x08, 0x8E);
|
||||
idt_set_gate(3, (uint32_t)isr3 , 0x08, 0x8E);
|
||||
idt_set_gate(4, (uint32_t)isr4 , 0x08, 0x8E);
|
||||
idt_set_gate(5, (uint32_t)isr5 , 0x08, 0x8E);
|
||||
idt_set_gate(6, (uint32_t)isr6 , 0x08, 0x8E);
|
||||
idt_set_gate(7, (uint32_t)isr7 , 0x08, 0x8E);
|
||||
idt_set_gate(8, (uint32_t)isr8 , 0x08, 0x8E);
|
||||
idt_set_gate(9, (uint32_t)isr9 , 0x08, 0x8E);
|
||||
idt_set_gate(10, (uint32_t)isr10, 0x08, 0x8E);
|
||||
idt_set_gate(11, (uint32_t)isr11, 0x08, 0x8E);
|
||||
idt_set_gate(12, (uint32_t)isr12, 0x08, 0x8E);
|
||||
idt_set_gate(13, (uint32_t)isr13, 0x08, 0x8E);
|
||||
idt_set_gate(14, (uint32_t)isr14, 0x08, 0x8E);
|
||||
idt_set_gate(15, (uint32_t)isr15, 0x08, 0x8E);
|
||||
idt_set_gate(16, (uint32_t)isr16, 0x08, 0x8E);
|
||||
idt_set_gate(17, (uint32_t)isr17, 0x08, 0x8E);
|
||||
idt_set_gate(18, (uint32_t)isr18, 0x08, 0x8E);
|
||||
idt_set_gate(19, (uint32_t)isr19, 0x08, 0x8E);
|
||||
idt_set_gate(20, (uint32_t)isr20, 0x08, 0x8E);
|
||||
idt_set_gate(21, (uint32_t)isr21, 0x08, 0x8E);
|
||||
idt_set_gate(22, (uint32_t)isr22, 0x08, 0x8E);
|
||||
idt_set_gate(23, (uint32_t)isr23, 0x08, 0x8E);
|
||||
idt_set_gate(24, (uint32_t)isr24, 0x08, 0x8E);
|
||||
idt_set_gate(25, (uint32_t)isr25, 0x08, 0x8E);
|
||||
idt_set_gate(26, (uint32_t)isr26, 0x08, 0x8E);
|
||||
idt_set_gate(27, (uint32_t)isr27, 0x08, 0x8E);
|
||||
idt_set_gate(28, (uint32_t)isr28, 0x08, 0x8E);
|
||||
idt_set_gate(29, (uint32_t)isr29, 0x08, 0x8E);
|
||||
idt_set_gate(30, (uint32_t)isr30, 0x08, 0x8E);
|
||||
idt_set_gate(31, (uint32_t)isr31, 0x08, 0x8E);
|
||||
idt_set_gate(32, (uint32_t)irq0, 0x08, 0x8e);
|
||||
idt_set_gate(33, (uint32_t)irq1, 0x08, 0x8e);
|
||||
idt_set_gate(34, (uint32_t)irq2, 0x08, 0x8e);
|
||||
idt_set_gate(35, (uint32_t)irq3, 0x08, 0x8e);
|
||||
idt_set_gate(36, (uint32_t)irq4, 0x08, 0x8e);
|
||||
idt_set_gate(37, (uint32_t)irq5, 0x08, 0x8e);
|
||||
idt_set_gate(38, (uint32_t)irq6, 0x08, 0x8e);
|
||||
idt_set_gate(39, (uint32_t)irq7, 0x08, 0x8e);
|
||||
idt_set_gate(40, (uint32_t)irq8, 0x08, 0x8e);
|
||||
idt_set_gate(41, (uint32_t)irq9, 0x08, 0x8e);
|
||||
idt_set_gate(42, (uint32_t)irq10, 0x08, 0x8e);
|
||||
idt_set_gate(43, (uint32_t)irq11, 0x08, 0x8e);
|
||||
idt_set_gate(44, (uint32_t)irq12, 0x08, 0x8e);
|
||||
idt_set_gate(45, (uint32_t)irq13, 0x08, 0x8e);
|
||||
idt_set_gate(46, (uint32_t)irq14, 0x08, 0x8e);
|
||||
idt_set_gate(47, (uint32_t)irq15, 0x08, 0x8e);
|
||||
idt_flush((uint32_t)&idt_ptr);
|
||||
}
|
||||
|
||||
//description table initialization function.
|
||||
void initialize_dt(){
|
||||
initialize_gdt();
|
||||
initialize_idt();
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#pragma once
|
||||
|
||||
#include"fs.h"
|
||||
#include<stdint.h>
|
||||
#include<stdbool.h>
|
||||
|
||||
//data entry structure.
|
||||
struct file_entry {
|
||||
//data name.
|
||||
uint8_t name[11];
|
||||
//attributes.
|
||||
uint8_t attributes;
|
||||
//reserved.
|
||||
uint8_t reserved;
|
||||
//creation date.
|
||||
uint8_t created_time_tenths;
|
||||
uint16_t created_time;
|
||||
uint16_t created_date;
|
||||
//last access date.
|
||||
uint16_t accessed_time;
|
||||
//first group upper part.
|
||||
uint16_t first_cluster_high;
|
||||
//date of last modification.
|
||||
uint16_t modified_time;
|
||||
uint16_t modified_date;
|
||||
//lower first group.
|
||||
uint16_t first_cluster_low;
|
||||
//data size.
|
||||
uint32_t size;
|
||||
} __attribute((packed));
|
||||
|
||||
//reads data from disk to the specified memory address.
|
||||
bool fread(const char* filename, uint32_t address) {
|
||||
file_entry* file;
|
||||
char* mem = (char*)0x30000;
|
||||
while ((char*)mem < (char*)0x50000) {
|
||||
if(compare_strings(filename, mem)==true) {
|
||||
file = (file_entry*)mem;
|
||||
break;
|
||||
}
|
||||
mem+=32;
|
||||
}
|
||||
//if the counter has arrived at the address 0x00050000 it means that the entry has not been found.
|
||||
if((uint8_t*)mem == (uint8_t*)0x00050000)
|
||||
return false;
|
||||
//calculates the block of logical address.
|
||||
uint32_t lba = ((bpb->BPB_RESERVED_SECTORS + bpb->BPB_FAT_NUMBER * bpb->BPB_SECTORS_PER_FAT + (bpb->BPB_DIR_ENTRIES_NUMBER * 32 + bpb-> BPB_BYTES_PER_SECTOR -1) / bpb->BPB_BYTES_PER_SECTOR)) + (file->first_cluster_low - 2) * bpb-> BPB_SECTORS_PER_CLUSTER;
|
||||
//read the sectors containing the requested data.
|
||||
read_sectors(address, lba, (file->size / bpb->BPB_BYTES_PER_SECTOR + 1));
|
||||
return true;
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
#pragma once
|
||||
|
||||
#include"stdio.h"
|
||||
#include"string.h"
|
||||
#include"ata.h"
|
||||
#include<stdint.h>
|
||||
|
||||
//structure of the parameter block of the SIEB.
|
||||
struct bios_parameter_block {
|
||||
uint8_t NOP[0x03]; //short jump and nop.
|
||||
uint8_t BPB_OEM[0x08]; //original equipment manufacturer code.
|
||||
uint16_t BPB_BYTES_PER_SECTOR; //number of octets per sector.
|
||||
uint8_t BPB_SECTORS_PER_CLUSTER; //number of sectors per group.
|
||||
uint16_t BPB_RESERVED_SECTORS; //number of reserved sectors.
|
||||
uint8_t BPB_FAT_NUMBER; //number of data allocation tables.
|
||||
uint16_t BPB_DIR_ENTRIES_NUMBER; //number of entries in the root path.
|
||||
uint16_t BPB_TOTAL_SECTORS; //total number of sectors.
|
||||
uint8_t BPB_MEDIA_DESCRIPTOR_TYPE; //memory device type code.
|
||||
uint16_t BPB_SECTORS_PER_FAT; //number of sectors per data allocation table.
|
||||
uint16_t BPB_SECTORS_PER_TRACK; //number of sectors per track.
|
||||
uint16_t BPB_HEAD_NUMBER; //number of heads.
|
||||
uint32_t BPB_HIDDEN_SECTORS; //number of hidden sectors.
|
||||
uint32_t BPB_LARGE_SECTOR_NUMBER; //number of wide sectors.
|
||||
} __attribute((packed));
|
||||
|
||||
//extended boot track structure.
|
||||
struct extended_boot_record {
|
||||
uint8_t EBR_DRIVE_NUMBER;//identification number of the storage device.
|
||||
uint8_t EBR_RESERVED;
|
||||
uint8_t EBR_SIGNATURE; //signature.
|
||||
uint32_t EBR_VOLUME_ID; //volume identification number
|
||||
uint8_t EBR_VOLUME_LABEL[0x0B]; //volume name
|
||||
uint8_t EBR_SYSTEM_ID; //disk structure type identification string.
|
||||
} __attribute((packed));
|
||||
|
||||
//declares a pointer to the structure of the SIEB's parameter block.
|
||||
bios_parameter_block* bpb;
|
||||
//declares a pointer to the extended boot trace structure.
|
||||
extended_boot_record* ebr;
|
||||
|
||||
//function of reading the data allocation table.
|
||||
void read_fat() {
|
||||
//read the data allocation table.
|
||||
read_sectors(0x20000, bpb->BPB_RESERVED_SECTORS, bpb->BPB_FAT_NUMBER * bpb->BPB_SECTORS_PER_FAT);
|
||||
return;
|
||||
}
|
||||
|
||||
//function of reading the root path.
|
||||
void read_root_dir() {
|
||||
//read the root path.
|
||||
read_sectors(0x30000, bpb->BPB_RESERVED_SECTORS + bpb->BPB_FAT_NUMBER * bpb->BPB_SECTORS_PER_FAT,
|
||||
(bpb->BPB_DIR_ENTRIES_NUMBER * 32 + bpb-> BPB_BYTES_PER_SECTOR -1) / bpb->BPB_BYTES_PER_SECTOR);
|
||||
return;
|
||||
}
|
||||
|
||||
//disk structure initialization function.
|
||||
void initialize_fs() {
|
||||
bpb = (bios_parameter_block*)0x00007C00;
|
||||
ebr = (extended_boot_record*)0x00007C24;
|
||||
read_fat();
|
||||
read_root_dir();
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
#pragma once
|
||||
|
||||
#include"stdio.h"
|
||||
#include"fs.h"
|
||||
#include"dt.h"
|
||||
#include"keyboard.h"
|
||||
#include"timer.h"
|
||||
#include"rtc.h"
|
||||
|
||||
//inizializza le componenti del gestore d'avvio.
|
||||
void initialize() {
|
||||
initialize_fs();
|
||||
initialize_dt();
|
||||
initialize_keyboard();
|
||||
initialize_timer(1.1931816666);
|
||||
initialize_rtc();
|
||||
//initialize_mouse();
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,162 @@
|
|||
#pragma once
|
||||
|
||||
#include"stdio.h"
|
||||
#include"ports.h"
|
||||
|
||||
typedef struct regs {
|
||||
uint32_t ds;
|
||||
uint32_t edi, esi, ebp, esp, ebx, edx, ecx, eax;
|
||||
uint32_t int_no, err_code;
|
||||
uint32_t eip, cs, eflags, useresp, ss;
|
||||
} registers_t;
|
||||
|
||||
typedef void (*isr_t)(registers_t);
|
||||
void register_interrupt_handler(uint8_t n, isr_t handler);
|
||||
|
||||
#define IRQ0 32
|
||||
#define IRQ1 33
|
||||
#define IRQ2 34
|
||||
#define IRQ3 35
|
||||
#define IRQ4 36
|
||||
#define IRQ5 37
|
||||
#define IRQ6 38
|
||||
#define IRQ7 39
|
||||
#define IRQ8 40
|
||||
#define IRQ9 41
|
||||
#define IRQ10 42
|
||||
#define IRQ11 43
|
||||
#define IRQ12 44
|
||||
#define IRQ13 45
|
||||
#define IRQ14 46
|
||||
#define IRQ15 47
|
||||
|
||||
#define DIVIDE_BY_ZERO 0
|
||||
#define DEBUG 1
|
||||
#define NON_MASKABLE_INTERRUPT 2
|
||||
#define BREAKPOINT 3
|
||||
#define OVERFLOW 4
|
||||
#define BOUND_RANGE_EXCEEDED 5
|
||||
#define INVALID_OPCODE 6
|
||||
#define DEVICE_NOT_AVAILABLE 7
|
||||
#define DOUBLE_FAULT 8
|
||||
#define COPROCESSOR_SEGMENT_OVERRUN 9
|
||||
#define INVALID_TSS 10
|
||||
#define SEGMENT_NOT_PRESENT 11
|
||||
#define STACK_SEGMENT_FAULT 12
|
||||
#define GENERAL_PROTECTION_FAULT 13
|
||||
#define PAGE_FAULT 14
|
||||
#define RESERVED1 15
|
||||
#define X87FLOATING_POINT_EXCEPTION 16
|
||||
#define ALIGMENT_CHECK 17
|
||||
#define MACHINE_CHECK 18
|
||||
#define SIMD_FLOATING_POINT_EXCEPTION 19
|
||||
#define VIRTUALIZATION_EXCEPTION 20
|
||||
#define CONTROL_PROTECTION_EXCEPTION 21
|
||||
#define RESERVED2 22
|
||||
#define RESERVED3 23
|
||||
#define RESERVED4 24
|
||||
#define RESERVED5 25
|
||||
#define RESERVED6 26
|
||||
#define RESERVED7 27
|
||||
#define HYPERVISOR_INJECTION_EXCEPTION 28
|
||||
#define VMM_COMUNICATION_EXCEPTION 29
|
||||
#define SECURITY_EXCEPTION 30
|
||||
#define RESERVED8 31
|
||||
|
||||
isr_t interrupt_handlers[256];
|
||||
|
||||
void register_interrupt_handler(uint8_t n, isr_t handler){ interrupt_handlers[n] = handler; }
|
||||
|
||||
extern "C" void isr_handler(registers_t regs){
|
||||
set_color(0x4);
|
||||
switch(regs.int_no) {
|
||||
case DIVIDE_BY_ZERO:
|
||||
printf("Divide by zero.");
|
||||
break;
|
||||
case DEBUG:
|
||||
printf("Debug.");
|
||||
break;
|
||||
case NON_MASKABLE_INTERRUPT:
|
||||
printf("Non maskable interrupt.");
|
||||
break;
|
||||
case BREAKPOINT:
|
||||
printf("Breakpoint.");
|
||||
break;
|
||||
case OVERFLOW:
|
||||
printf("Overflow.");
|
||||
break;
|
||||
case BOUND_RANGE_EXCEEDED:
|
||||
printf("Bound range exceeded.");
|
||||
break;
|
||||
case INVALID_OPCODE:
|
||||
printf("Invalid opcode.");
|
||||
break;
|
||||
case DEVICE_NOT_AVAILABLE:
|
||||
printf("Device not available.");
|
||||
break;
|
||||
case DOUBLE_FAULT:
|
||||
printf("Double fault.");
|
||||
asm("cli; hlt");
|
||||
break;
|
||||
case COPROCESSOR_SEGMENT_OVERRUN:
|
||||
printf("Coprocessor segment overrun.");
|
||||
break;
|
||||
case INVALID_TSS:
|
||||
printf("Invalid TSS.");
|
||||
break;
|
||||
case SEGMENT_NOT_PRESENT:
|
||||
printf("Segment not present.");
|
||||
break;
|
||||
case STACK_SEGMENT_FAULT:
|
||||
printf("Stack segment fault.");
|
||||
break;
|
||||
case GENERAL_PROTECTION_FAULT:
|
||||
printf("General protection fault.");
|
||||
break;
|
||||
case PAGE_FAULT:
|
||||
printf("Page fault.");
|
||||
break;
|
||||
case X87FLOATING_POINT_EXCEPTION:
|
||||
printf("x87 floating point exception.");
|
||||
break;
|
||||
case ALIGMENT_CHECK:
|
||||
printf("Aligment check.");
|
||||
break;
|
||||
case MACHINE_CHECK:
|
||||
printf("Machine check.");
|
||||
asm("cli; hlt");
|
||||
break;
|
||||
case SIMD_FLOATING_POINT_EXCEPTION:
|
||||
printf("SIMD floating point exception.");
|
||||
break;
|
||||
case VIRTUALIZATION_EXCEPTION:
|
||||
printf("Virtualization exception.");
|
||||
break;
|
||||
case CONTROL_PROTECTION_EXCEPTION:
|
||||
printf("Control protection exception.");
|
||||
break;
|
||||
case HYPERVISOR_INJECTION_EXCEPTION:
|
||||
printf("Hypervisor injection exception.");
|
||||
break;
|
||||
case VMM_COMUNICATION_EXCEPTION:
|
||||
printf("VMM comunication exception.");
|
||||
break;
|
||||
case SECURITY_EXCEPTION:
|
||||
printf("Security exception.");
|
||||
break;
|
||||
default:
|
||||
printf("unhandled interrupt 0x%x\n", regs.int_no);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void irq_handler(registers_t r){
|
||||
if(r.int_no >= 40){
|
||||
outb(0xa0, 0x20);
|
||||
}
|
||||
outb(0x20, 0x20);
|
||||
if(interrupt_handlers[r.int_no] != 0){
|
||||
isr_t handler = interrupt_handlers[r.int_no];
|
||||
handler(r);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,172 @@
|
|||
#pragma once
|
||||
|
||||
#include"stdio.h"
|
||||
#include"isr.h"
|
||||
#include"system.h"
|
||||
#include"rtc.h"
|
||||
#include"fat12.h"
|
||||
#include<stdint.h>
|
||||
//#include"vga.h"
|
||||
|
||||
//lowercase key list. (trq)
|
||||
const char sc_table[] ={
|
||||
0x00, 0x00, '1', '2',
|
||||
'3', '4', '5', '6',
|
||||
'7', '8', '9', '0',
|
||||
'-', '=', 0x00, 0x00,
|
||||
'q', 'w', 'e', 'r',
|
||||
't', 'y', 'u', 'i',
|
||||
'o', 'p', 'g', 'u',
|
||||
0x00, 0x00, 'a', 's',
|
||||
'd', 'f', 'g', 'h',
|
||||
'j', 'k', 'l', 's',
|
||||
'i', ',', 0x00, '\\',
|
||||
'z', 'x', 'c', 'v',
|
||||
'b', 'n', 'm', 'o',
|
||||
'c', '.', 0x00, '*',
|
||||
0x00, ' '
|
||||
};
|
||||
|
||||
//shift key list.
|
||||
const char sc_tableC[] ={
|
||||
0x00, 0x00, '!', '@',
|
||||
'^', '+', '%', '&',
|
||||
'/', '(', ')', '=',
|
||||
'?', '_', 0x00, 0x00,
|
||||
'Q', 'W', 'E', 'R',
|
||||
'T', 'Y', 'U', 'I',
|
||||
'O', 'P', '{', '}',
|
||||
0x00, 0x00, 'A', 'S',
|
||||
'D', 'F', 'G', 'H',
|
||||
'J', 'K', 'L', ':',
|
||||
'"', '~', 0x00, '|',
|
||||
'Z', 'X', 'C', 'V',
|
||||
'B', 'N', 'M', '<',
|
||||
'>', '?', 0x00, '*',
|
||||
0x00, ' '
|
||||
};
|
||||
|
||||
int lshift = 0x00;
|
||||
int rshift = 0x00;
|
||||
|
||||
void keyboard_handler(registers_t regs){
|
||||
//gets the key pressed.
|
||||
uint8_t k = inb(0x60);
|
||||
uint8_t c = 0x00;
|
||||
//translate the keyboard code into a letter character.
|
||||
if(k < 0x3A)
|
||||
c = sc_table[k];
|
||||
//if the pressed letter is a character.
|
||||
if(c != 0x00){
|
||||
//check if the shift keys are pressed.
|
||||
switch(lshift | rshift){
|
||||
case 0x01: //uppercase.
|
||||
buffer[_buf] = sc_tableC[k];
|
||||
putc(sc_tableC[k]);
|
||||
_buf++;
|
||||
buffer[_buf] = 0x00;
|
||||
break;
|
||||
case 0x00: //lowercase.
|
||||
buffer[_buf] = c;
|
||||
putc(c);
|
||||
_buf++;
|
||||
buffer[_buf] = 0x00;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
//if the key pressed has zero as a value check the code.
|
||||
switch(k){
|
||||
case 0x0E: //clear back key.
|
||||
if(_buf!=0x00) {
|
||||
_buf--;
|
||||
buffer[_buf] = 0x00;
|
||||
putcback();
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x2A: //left shift key pressed.
|
||||
lshift = 0x01;
|
||||
break;
|
||||
|
||||
case 0xAA: //left shift key released.
|
||||
lshift = 0x00;
|
||||
rshift = 0x00;
|
||||
break;
|
||||
|
||||
case 0x36: //right shift key pressed.
|
||||
rshift = 0x01;
|
||||
break;
|
||||
|
||||
case 0xb6: //right shift key released.
|
||||
lshift = 0x00;
|
||||
rshift = 0x00;
|
||||
break;
|
||||
|
||||
case 0x3A: //caps lock pressed.
|
||||
if(lshift == 0x00){
|
||||
lshift = 0x01;
|
||||
}
|
||||
else {
|
||||
lshift = 0x00;
|
||||
}
|
||||
break;
|
||||
|
||||
case 0x1C: //enter pressed.
|
||||
printf("\n");
|
||||
if(compare_strings_ws("help", buffer) == true){
|
||||
printf("help - prints a list of available commands.\n");
|
||||
printf("dir - prints the contents of the root directory.\n");
|
||||
printf("time - prints the current time.\n");
|
||||
} else if(compare_strings_ws("dir", buffer) == true) {
|
||||
file_entry* file;
|
||||
char* mem = (char*)0x30000;
|
||||
while ((char*)mem < (char*)0x50000) {
|
||||
file = (file_entry*)mem;
|
||||
if(file->size == 0)
|
||||
break;
|
||||
printf("%s %d bytes\n", mem, file->size);
|
||||
mem += 32;
|
||||
}
|
||||
} else if(compare_strings_ws("time", buffer) == true) {
|
||||
printf("%d/%d/%d - %d:%d:%d\n", time.day_of_month, time.month, time.year, time.hour, time.minute, time.second);
|
||||
} else if(fread(buffer, 0x150000)){
|
||||
void (*app)(void) = (void (*)())0x150000;
|
||||
app();
|
||||
} else if(compare_strings_ws("echo", buffer) == true){
|
||||
printf("echo\n");
|
||||
} else if(compare_strings_ws("clear", buffer) == true){
|
||||
//clear function
|
||||
int i=0;
|
||||
|
||||
// empty text with white text.
|
||||
signed char blankCell = string_size(" ");
|
||||
|
||||
for (i = 0; i < 25; i++){
|
||||
for (int j = 0; j < 80; j++) {
|
||||
video_memory[2 * (80 * i + j)] = '\0';
|
||||
video_memory[2 * (80 * i + j) + 1] = 0x0B;
|
||||
}
|
||||
}
|
||||
//initialize_keyboard();
|
||||
//update_cursor_pos(0x00,0x00);
|
||||
}else if(compare_strings_ws("poweroff", buffer) == true){
|
||||
outw(0xB004, 0x2000);
|
||||
outw(0x604, 0x2000);
|
||||
outw(0x4004, 0x3400);
|
||||
} else {
|
||||
printf("'%s' komutu bulunamadi\n",buffer);
|
||||
}
|
||||
clear_string(buffer);
|
||||
_buf = 0;
|
||||
printf(">_");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//keyboard initialization function.
|
||||
void initialize_keyboard(){
|
||||
//initialize the keyboard switch.
|
||||
register_interrupt_handler(IRQ1, &keyboard_handler);
|
||||
*buffer = 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
#pragma once
|
||||
|
||||
// declaration of constants.
|
||||
const double PI = 3.141592653589793;
|
||||
const double HALF_PI = 1.570796326794897;
|
||||
const double DOUBLE_PI = 6.283185307179586;
|
||||
const double SIN_CURVE_A = 0.0415896;
|
||||
const double SIN_CURVE_B = 0.00129810625032;
|
||||
|
||||
//structure of a two-dimensional vector of integers.
|
||||
struct vec2i {
|
||||
int x, y;
|
||||
};
|
||||
|
||||
//structure of a three-dimensional vector of integers.
|
||||
struct vec3i {
|
||||
int x, y;
|
||||
};
|
||||
|
||||
//structure of a two-dimensional vector of rational numbers.
|
||||
struct vec2f {
|
||||
float x, y;
|
||||
};
|
||||
|
||||
//structure of a three-dimensional vector of rational numbers.
|
||||
struct vec3f {
|
||||
float x, y;
|
||||
};
|
||||
|
||||
//function to find the absolute value of an integer.
|
||||
//#define abs(x) (if(x<0) -x; x)
|
||||
int abs(int x) {
|
||||
if(x < 0)
|
||||
return -x;
|
||||
return x;
|
||||
}
|
||||
|
||||
int sgn(int x) { //function to find the sign of an integer.
|
||||
if(x < 0)
|
||||
return -1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
float sqrt(float number) { //function to find the square root of a rational number.
|
||||
int start = 0, end = number;
|
||||
int mid;
|
||||
float ans;
|
||||
while (start <= end) {
|
||||
mid = (start + end) / 2;
|
||||
if (mid * mid == number) {
|
||||
ans = mid;
|
||||
break;
|
||||
}
|
||||
if (mid * mid < number) {
|
||||
ans=start;
|
||||
start = mid + 1;
|
||||
}
|
||||
else {
|
||||
end = mid - 1;
|
||||
}
|
||||
}
|
||||
float increment = 0.1;
|
||||
int i;
|
||||
for (i = 0; i < 5; i++) {
|
||||
while (ans * ans <= number) {
|
||||
ans += increment;
|
||||
}
|
||||
ans = ans - increment;
|
||||
increment = increment / 10;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
//function to compute the power of a given base with a given exponent.
|
||||
int pow(int base, int exponent) {
|
||||
int result = 1;
|
||||
for (;;) {
|
||||
if (exponent & 1)
|
||||
result *= base;
|
||||
exponent >>= 1;
|
||||
if (!exponent)
|
||||
break;
|
||||
base *= base;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
//function for calculating the cos.
|
||||
double cos(double x) {
|
||||
if (x < 0) {
|
||||
int q = -x / DOUBLE_PI;
|
||||
q += 1;
|
||||
double y = q * DOUBLE_PI;
|
||||
x = -(x - y);
|
||||
}
|
||||
if (x >= DOUBLE_PI) {
|
||||
int q = x / DOUBLE_PI;
|
||||
double y = q * DOUBLE_PI;
|
||||
x = x - y;
|
||||
}
|
||||
int s = 1;
|
||||
if (x >= PI) {
|
||||
s = -1;
|
||||
x -= PI;
|
||||
}
|
||||
if (x > HALF_PI) {
|
||||
x = PI - x;
|
||||
s = -s;
|
||||
}
|
||||
double z = x * x;
|
||||
double r = z * (z * (SIN_CURVE_A - SIN_CURVE_B * z) - 0.5) + 1.0;
|
||||
if (r > 1.0) r = r - 2.0;
|
||||
if (s > 0) return r;
|
||||
else return -r;
|
||||
}
|
||||
|
||||
//sin calculation function.
|
||||
double sin(double x) {
|
||||
return cos(x - HALF_PI);
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#pragma once
|
||||
|
||||
//function to set a given part of memory to a destination with a value for a given length.
|
||||
void* memset(void *dest, int val, unsigned int len) {
|
||||
char* ptr = (char*)dest;
|
||||
while (len-- > 0) *ptr++ = val;
|
||||
return dest;
|
||||
}
|
||||
|
||||
//function to copy a given part of memory from a source to a destination for a given length.
|
||||
void* memcpy(void *dest, const void *src, int n) {
|
||||
char* d = (char*)dest;
|
||||
char* s = (char*)src;
|
||||
while(n--)
|
||||
*(d++) = *(s++);
|
||||
return dest;
|
||||
}
|
||||
|
||||
//function to copy a given part of memory from a source to a destination for a given length with the SSE.
|
||||
extern "C" int memcpy_sse(void* dst, void* src, unsigned int count);
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#pragma once
|
||||
|
||||
#include"stdio.h"
|
||||
#include"system.h"
|
||||
#include"pic.h"
|
||||
#include"ports.h"
|
||||
|
||||
char mouse_cycle = 0;
|
||||
signed char mouse_byte[3];
|
||||
|
||||
int mouse_x = 100;
|
||||
int mouse_y = 100;
|
||||
|
||||
void mouse_wait(uint8_t a_type) {
|
||||
uint32_t _time_out=100000;
|
||||
if(a_type==0) {
|
||||
while(_time_out--) {
|
||||
if((inb(0x64) & 1)==1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
else {
|
||||
while(_time_out--) {
|
||||
if((inb(0x64) & 2)==0) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void mouse_write(uint8_t a_write) {
|
||||
mouse_wait(1);
|
||||
outb(0x64, 0xD4);
|
||||
mouse_wait(1);
|
||||
outb(0x60, a_write);
|
||||
}
|
||||
|
||||
uint8_t mouse_read() {
|
||||
mouse_wait(0);
|
||||
return inb(0x60);
|
||||
}
|
||||
|
||||
void mouse_handler(registers_t regs) {
|
||||
switch(mouse_cycle) {
|
||||
case 0:
|
||||
mouse_byte[0]=inb(0x60);
|
||||
mouse_cycle++;
|
||||
break;
|
||||
case 1:
|
||||
mouse_byte[1]=inb(0x60);
|
||||
mouse_cycle++;
|
||||
break;
|
||||
case 2:
|
||||
mouse_byte[2]=inb(0x60);
|
||||
mouse_x += mouse_byte[1];
|
||||
mouse_y -= mouse_byte[2];
|
||||
mouse_cycle=0;
|
||||
break;
|
||||
}
|
||||
outb(0xA0, 0x20);
|
||||
}
|
||||
|
||||
void initialize_mouse(){
|
||||
uint8_t _status;
|
||||
mouse_wait(1);
|
||||
outb(0x64, 0xA8);
|
||||
mouse_wait(1);
|
||||
outb(0x64, 0x20);
|
||||
mouse_wait(0);
|
||||
_status=(inb(0x60) | 2);
|
||||
mouse_wait(1);
|
||||
outb(0x64, 0x60);
|
||||
mouse_wait(1);
|
||||
outb(0x60, _status);
|
||||
mouse_write(0xF6);
|
||||
mouse_read();
|
||||
mouse_write(0xF4);
|
||||
mouse_read();
|
||||
IRQ_clear_mask(12);
|
||||
register_interrupt_handler(IRQ12, &mouse_handler);
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#pragma once
|
||||
|
||||
#include"ports.h"
|
||||
|
||||
#define PIC1 0x20 /* IO base address for master PIC */
|
||||
#define PIC2 0xA0 /* IO base address for slave PIC */
|
||||
#define PIC1_COMMAND PIC1
|
||||
#define PIC1_DATA (PIC1+1)
|
||||
#define PIC2_COMMAND PIC2
|
||||
#define PIC2_DATA (PIC2+1)
|
||||
|
||||
void IRQ_set_mask(unsigned char IRQline) {
|
||||
uint16_t port;
|
||||
uint8_t value;
|
||||
|
||||
if(IRQline < 8) {
|
||||
port = PIC1_DATA;
|
||||
} else {
|
||||
port = PIC2_DATA;
|
||||
IRQline -= 8;
|
||||
}
|
||||
value = inb(port) | (1 << IRQline);
|
||||
outb(port, value);
|
||||
return;
|
||||
}
|
||||
|
||||
void IRQ_clear_mask(unsigned char IRQline) {
|
||||
uint16_t port;
|
||||
uint8_t value;
|
||||
|
||||
if(IRQline < 8) {
|
||||
port = PIC1_DATA;
|
||||
} else {
|
||||
port = PIC2_DATA;
|
||||
IRQline -= 8;
|
||||
}
|
||||
value = inb(port) & ~(1 << IRQline);
|
||||
outb(port, value);
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#pragma once
|
||||
|
||||
#include<stdint.h>
|
||||
|
||||
//output function of an octet to an input and output port.
|
||||
static inline void outb(uint16_t port, uint8_t value) {
|
||||
asm("outb %0, %1" : : "a"(value), "Nd"(port));
|
||||
return;
|
||||
}
|
||||
|
||||
//input function of an octet to an input and output port.
|
||||
static inline uint8_t inb(uint16_t port) {
|
||||
uint8_t value;
|
||||
asm("inb %1, %0" : "=a"(value) : "Nd"(port));
|
||||
return value;
|
||||
}
|
||||
|
||||
//output function of two octets to one input and output port.
|
||||
static inline void outw(uint16_t port, uint16_t value) {
|
||||
asm("out %%ax, %%dx" : : "a"(value), "d"(port));
|
||||
return;
|
||||
}
|
||||
|
||||
//input function of two octets to an input and output port.
|
||||
static inline uint16_t inw(uint16_t port) {
|
||||
uint16_t value;
|
||||
asm("in %%dx, %%ax" : "=a"(value) : "d"(port));
|
||||
return value;
|
||||
}
|
||||
|
||||
//output function of four octets to one input and output port.
|
||||
static inline void outd(uint32_t port, uint32_t value) {
|
||||
asm("outl %%eax, %%dx" : : "a"(value), "d"(port));
|
||||
}
|
||||
|
||||
//input function of four octets to an input and output port.
|
||||
static inline uint32_t ind(uint32_t port) {
|
||||
uint32_t value;
|
||||
asm("inl %%dx, %%eax" : "=a"(value) : "d"(port));
|
||||
return value;
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
#pragma once
|
||||
|
||||
#include"ports.h"
|
||||
|
||||
typedef struct {
|
||||
char second;
|
||||
char minute;
|
||||
char hour;
|
||||
char day_of_week;
|
||||
char day_of_month;
|
||||
char month;
|
||||
char year;
|
||||
} time_t;
|
||||
|
||||
time_t time;
|
||||
bool bcd;
|
||||
|
||||
//function to write to real time clock registers.
|
||||
char read_register(unsigned char reg) {
|
||||
outb(0x70, reg);
|
||||
return inb(0x71);
|
||||
}
|
||||
|
||||
//function to read from real time clock registers.
|
||||
void write_register(unsigned char reg, unsigned char value) {
|
||||
outb(0x70, reg);
|
||||
outb(0x71, value);
|
||||
}
|
||||
|
||||
char bcd2bin(unsigned char bcd) {
|
||||
return ((bcd >> 4) * 10) + (bcd & 0x0F);
|
||||
}
|
||||
|
||||
void gettime(time_t *time) {
|
||||
memcpy_sse(time, &time, sizeof(time_t));
|
||||
}
|
||||
|
||||
//real time clock management function.
|
||||
void rtc_handler(registers_t regs) {
|
||||
if(read_register(0x0C) & 0x10){
|
||||
if(bcd){
|
||||
time.second = bcd2bin(read_register(0x00));
|
||||
time.minute = bcd2bin(read_register(0x02));
|
||||
time.hour = bcd2bin(read_register(0x04));
|
||||
time.month = bcd2bin(read_register(0x08));
|
||||
time.year = bcd2bin(read_register(0x09));
|
||||
time.day_of_week = bcd2bin(read_register(0x06));
|
||||
time.day_of_month = bcd2bin(read_register(0x07));
|
||||
}else {
|
||||
time.second = read_register(0x00);
|
||||
time.minute = read_register(0x02);
|
||||
time.hour = read_register(0x04);
|
||||
time.month = read_register(0x08);
|
||||
time.year = read_register(0x09);
|
||||
time.day_of_week = read_register(0x06);
|
||||
time.day_of_month = read_register(0x07);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//real time clock initialization function.
|
||||
void initialize_rtc() {
|
||||
unsigned char status;
|
||||
status = read_register(0x0B);
|
||||
status |= 0x02;
|
||||
status |= 0x10;
|
||||
status &= ~0x20;
|
||||
status &= ~0x40;
|
||||
bcd = !(status & 0x04);
|
||||
write_register(0x0B, status);
|
||||
read_register(0x0C);
|
||||
register_interrupt_handler(IRQ8, &rtc_handler);
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
#pragma once
|
||||
|
||||
//function to enable the SSE https://wiki.osdev.org/SSE
|
||||
extern "C" void enable_sse();
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
#pragma once
|
||||
|
||||
#include"string.h"
|
||||
#include"ports.h"
|
||||
#include<stdint.h>
|
||||
#include<stdarg.h>
|
||||
|
||||
uint16_t x_pos = 0x0000, y_pos = 0x0000; //cursor position.
|
||||
//text color.
|
||||
uint8_t color = 0x07;
|
||||
//color of test
|
||||
uint8_t bg_color = 0x00;
|
||||
|
||||
//text mode memory address 0x03.
|
||||
uint32_t* video_memory = (uint32_t*)0x000B8000;
|
||||
|
||||
//set the text color.
|
||||
void set_color(uint8_t new_color) {
|
||||
color = new_color;
|
||||
return;
|
||||
}
|
||||
|
||||
//set the background color of the text.
|
||||
void set_bg_color(uint8_t new_color) {
|
||||
bg_color = new_color;
|
||||
return;
|
||||
}
|
||||
|
||||
//scrolls text down one line.
|
||||
void scroll() {
|
||||
uint8_t attribute = (0x00 << 0x04) | (0x0F & 0x0F);
|
||||
uint16_t blank = 0x0020 | (attribute << 0x0008);
|
||||
if(y_pos >= 0x0019) {
|
||||
for(uint32_t i = 0x00000000 * 0x00000050; i < 0x00000018 * 0x00000050; i++)
|
||||
video_memory[i] = video_memory[i + 0x00000050];
|
||||
for(uint32_t i = 0x00000018 * 0x00000050; i < 0x00000019 * 0x00000050; i++)
|
||||
video_memory[i] = blank;
|
||||
y_pos = 0x0018;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
//updates the position of the cursor on the screen.
|
||||
void update_cursor_pos(uint16_t x, uint16_t y) {
|
||||
uint16_t cursor_pos = y * 0x0050 + x;
|
||||
outb(0x03D4, 0x0F);
|
||||
outb(0x03D5, (uint8_t)(cursor_pos & 0xFF));
|
||||
outb(0x03D4, 0x0E);
|
||||
outb(0x03D5, (uint8_t)((cursor_pos >> 0x08) & 0xFF));
|
||||
return;
|
||||
}
|
||||
|
||||
//writes a character on the screen by advancing the cursor position.
|
||||
void putc(unsigned char c){
|
||||
uint16_t attrib = (0 << 4) | (color & 0x0F);
|
||||
volatile uint16_t* where;
|
||||
where = (volatile uint16_t *)0xB8000 + (y_pos * 80 + x_pos);
|
||||
*where = c | (attrib << 8);
|
||||
if(++x_pos >= 80){
|
||||
x_pos = 0;
|
||||
y_pos++;
|
||||
}
|
||||
update_cursor_pos(x_pos, y_pos);
|
||||
if(y_pos >= 25) {
|
||||
x_pos = 0;
|
||||
scroll();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
//removes a character on the screen by moving the cursor back.
|
||||
void putcback(){
|
||||
uint16_t attrib = (0 << 4) | (color & 0x0F);
|
||||
volatile uint16_t * where;
|
||||
x_pos--;
|
||||
if(x_pos < 0) {
|
||||
x_pos = 79;
|
||||
y_pos--;
|
||||
}
|
||||
where = (volatile uint16_t *)0xB8000 + (y_pos * 80 + x_pos);
|
||||
*where = ' ' | (attrib << 8);
|
||||
update_cursor_pos(x_pos, y_pos);
|
||||
if(y_pos >= 25) {
|
||||
x_pos = 0;
|
||||
scroll();
|
||||
}
|
||||
}
|
||||
|
||||
//writes a string to the screen by advancing the cursor position.
|
||||
void puts(char* string){
|
||||
uint16_t i;
|
||||
while(*string){
|
||||
switch(*string){
|
||||
case 0x0A:
|
||||
x_pos = 0x0000;
|
||||
y_pos++;
|
||||
*string++;
|
||||
scroll();
|
||||
break;
|
||||
case 0x09:
|
||||
for(i = 0x0000; i <= 0x0008; i++) {
|
||||
putc(' ');
|
||||
}
|
||||
*string++;
|
||||
break;
|
||||
default:
|
||||
putc(*string);
|
||||
*string++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
update_cursor_pos(x_pos, y_pos);
|
||||
return;
|
||||
}
|
||||
|
||||
//writes a rich string to the screen by advancing the cursor position.
|
||||
void printf(char* format, ...) {
|
||||
va_list ap;
|
||||
va_start(ap, format);
|
||||
char* pointer;
|
||||
for (pointer = format; *pointer != 0x00; pointer++) {
|
||||
if (*pointer == '%') {
|
||||
++pointer;
|
||||
switch (*pointer) {
|
||||
case 0x63:
|
||||
putc(va_arg(ap, int));
|
||||
break;
|
||||
case 0x73:
|
||||
puts(va_arg(ap, char*));
|
||||
break;
|
||||
case 0x64:
|
||||
puts(int_to_string(va_arg(ap, int), 10));
|
||||
break;
|
||||
case 0x78:
|
||||
puts(int_to_string(va_arg(ap, uint32_t), 16));
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
char t[2] = {*pointer, 0};
|
||||
puts(t);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#pragma once
|
||||
|
||||
#include<stdint.h>
|
||||
#include<stdbool.h>
|
||||
|
||||
//converts a number to a string.
|
||||
char* int_to_string(unsigned int num, int base) {
|
||||
static char repr[]= "0123456789ABCDEF";
|
||||
static char buffer[50];
|
||||
char *ptr;
|
||||
|
||||
ptr = &buffer[49];
|
||||
*ptr = '\0';
|
||||
|
||||
do {
|
||||
*--ptr = repr[num%base];
|
||||
num /= base;
|
||||
}while(num != 0);
|
||||
|
||||
return(ptr);
|
||||
}
|
||||
|
||||
//compare two strings.
|
||||
bool compare_strings(const char* string1, const char* string2) {
|
||||
while(*string1!=0) {
|
||||
if(*string1 != *string2)
|
||||
return false;
|
||||
string1++;
|
||||
string2++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
//compares two strings and returns false if they are different.
|
||||
bool compare_strings_ws(const char* string1, const char* string2) {
|
||||
while(1) {
|
||||
if(*string1==0 && *string2!=0)
|
||||
return false;
|
||||
if(*string1==0)
|
||||
return true;
|
||||
if(*string1 != *string2)
|
||||
return false;
|
||||
string1++;
|
||||
string2++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void clear_string(char* string) { //empties a string.
|
||||
while(*string != 0) {
|
||||
*string = 0;
|
||||
string++;
|
||||
}
|
||||
return;
|
||||
}
|
||||
/*
|
||||
void restore_memory(long unsigned int* a){
|
||||
while(a != 0x00){
|
||||
a == 0x00;
|
||||
}
|
||||
return;
|
||||
}
|
||||
*/
|
||||
int string_size(char* string) { //returns the length of a string.
|
||||
int counter = 0;
|
||||
while(*string != 0) {
|
||||
string++;
|
||||
counter++;
|
||||
}
|
||||
return counter;
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
#pragma once
|
||||
|
||||
//klavye girişi için bellek.
|
||||
char* buffer;
|
||||
int _buf = 0;
|
||||
|
||||
//anahtarları devre dışı bırakma işlevi.
|
||||
extern "C" void disable_ints();
|
||||
|
||||
//anahtarları etkinleştirme işlevi.
|
||||
extern "C" void enable_ints();
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#pragma once
|
||||
|
||||
#include"stdio.h"
|
||||
#include"isr.h"
|
||||
#include"ports.h"
|
||||
|
||||
//moments past.
|
||||
uint32_t tick = 0;
|
||||
|
||||
//function to obtain a random number given the maximum value.
|
||||
int random(int numLimit) {
|
||||
static int randSeed, needsInit = 1;
|
||||
if (needsInit) {
|
||||
randSeed = tick;
|
||||
needsInit = 0;
|
||||
}
|
||||
randSeed = (randSeed * 32719 + 3) % 32749;
|
||||
return (randSeed % numLimit) + 1;
|
||||
}
|
||||
|
||||
//clock management function.
|
||||
static void timer_callback(registers_t regs) {
|
||||
tick++;
|
||||
}
|
||||
|
||||
//clock initialization function.
|
||||
void initialize_timer(uint32_t frequency) {
|
||||
register_interrupt_handler(IRQ0, &timer_callback);
|
||||
uint32_t divisor = 1193180 / frequency;
|
||||
outb(0x43, 0x36);
|
||||
uint8_t l = (uint8_t)(divisor & 0xFF);
|
||||
uint8_t h = (uint8_t)((divisor>>8) & 0xff);
|
||||
outb(0x40, l);
|
||||
outb(0x40, h);
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include"stdio.h"
|
||||
#define VIDEO_MEMORY_ADDRESS 0xb8000;
|
||||
#define WIDTH 80
|
||||
#define HEIGHT 25
|
||||
|
||||
|
||||
static short xx=0;
|
||||
static short yy=0;
|
||||
|
||||
unsigned int strlen(char *str){
|
||||
unsigned int len=0;
|
||||
while(str[len]){
|
||||
len++;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
void vga_init(){
|
||||
short *buffer=(short *)VIDEO_MEMORY_ADDRESS;
|
||||
for(short i=0;i<=80*25*2;i++){
|
||||
buffer[i]=0x4020;
|
||||
}
|
||||
}
|
||||
void term_put(char *str){
|
||||
short *buffer=(short *)VIDEO_MEMORY_ADDRESS;
|
||||
for(char i=0;i<=strlen(str);i++){
|
||||
if(str[i]=='\n'|| xx==WIDTH){
|
||||
yy++;
|
||||
xx=0;
|
||||
}else{
|
||||
if(str[i]!='\0'){
|
||||
buffer[yy*WIDTH+xx]=str[i]|0x40<<8;
|
||||
}
|
||||
xx++;
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
void clearKOD(){
|
||||
int i=0;
|
||||
|
||||
// empty text with white text.
|
||||
signed int blankCell = string_size(" ");
|
||||
|
||||
for (i = 0; i < HEIGHT; i++){
|
||||
for (int j = 0; j < WIDTH; j++) {
|
||||
video_memory[2 * (WIDTH * i + j)] = '\0';
|
||||
video_memory[2 * (WIDTH * i + j) + 1] = 0x0B;
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
|
@ -0,0 +1,219 @@
|
|||
[BITS 32]
|
||||
;kernel.cpp yukle
|
||||
[EXTERN main]
|
||||
;main fonction
|
||||
call main
|
||||
;creates an infinite loop by jumping to the current memory address.
|
||||
jmp $
|
||||
|
||||
[GLOBAL memcpy_sse]
|
||||
memcpy_sse:
|
||||
push ebp
|
||||
mov ebp, esp
|
||||
push esi
|
||||
push edi
|
||||
pushf
|
||||
cld
|
||||
mov edi, [ebp + 8]
|
||||
mov esi, [ebp + 12]
|
||||
mov eax, [ebp + 16]
|
||||
mov ecx, eax
|
||||
shr ecx, 6
|
||||
jz .endloop64
|
||||
.loop64:
|
||||
prefetchnta [esi + 64]
|
||||
prefetchnta [esi + 96]
|
||||
movq mm1, [esi + 0]
|
||||
movq mm2, [esi + 8]
|
||||
movq mm3, [esi + 16]
|
||||
movq mm4, [esi + 24]
|
||||
movq mm5, [esi + 32]
|
||||
movq mm6, [esi + 40]
|
||||
movq mm7, [esi + 48]
|
||||
movq mm0, [esi + 56]
|
||||
movntq [edi + 0], mm1
|
||||
movntq [edi + 8], mm2
|
||||
movntq [edi + 16], mm3
|
||||
movntq [edi + 24], mm4
|
||||
movntq [edi + 32], mm5
|
||||
movntq [edi + 40], mm6
|
||||
movntq [edi + 48], mm7
|
||||
movntq [edi + 56], mm0
|
||||
add esi, 64
|
||||
add edi, 64
|
||||
loop .loop64
|
||||
emms
|
||||
.endloop64:
|
||||
mov ecx, eax
|
||||
and ecx, 0x3F
|
||||
shr ecx, 3
|
||||
jz .endloop8
|
||||
.loop8:
|
||||
movq mm1, [esi]
|
||||
movq [edi], mm1
|
||||
add esi, 8
|
||||
add edi, 8
|
||||
loop .loop8
|
||||
emms
|
||||
.endloop8:
|
||||
mov ecx, eax
|
||||
and ecx, 7
|
||||
repe movsb
|
||||
.done:
|
||||
popf
|
||||
pop edi
|
||||
pop esi
|
||||
mov esp, ebp
|
||||
pop ebp
|
||||
ret
|
||||
|
||||
[GLOBAL enable_sse]
|
||||
enable_sse:
|
||||
mov eax, cr0
|
||||
and ax, 0xFFFB
|
||||
or ax, 0x2
|
||||
mov cr0, eax
|
||||
mov eax, cr4
|
||||
or ax, 3 << 9
|
||||
mov cr4, eax
|
||||
ret
|
||||
|
||||
[GLOBAL gdt_flush]
|
||||
gdt_flush:
|
||||
mov eax, [esp+4]
|
||||
lgdt [eax]
|
||||
mov eax, 0x10
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov fs, ax
|
||||
mov gs, ax
|
||||
mov ss, ax
|
||||
jmp 0x08:.flush
|
||||
.flush:
|
||||
ret
|
||||
|
||||
[GLOBAL idt_flush]
|
||||
idt_flush:
|
||||
mov eax, [esp+4]
|
||||
lidt [eax]
|
||||
sti
|
||||
ret
|
||||
|
||||
%MACRO ISR_NOERRCODE 1
|
||||
[GLOBAL isr%1]
|
||||
isr%1:
|
||||
cli
|
||||
push byte 0
|
||||
push byte %1
|
||||
jmp isr_common_stub
|
||||
%ENDMACRO
|
||||
|
||||
%MACRO ISR_ERRCODE 1
|
||||
[GLOBAL isr%1]
|
||||
isr%1:
|
||||
cli
|
||||
push byte %1
|
||||
jmp isr_common_stub
|
||||
%ENDMACRO
|
||||
|
||||
%MACRO IRQ 2
|
||||
[GLOBAL irq%1]
|
||||
irq%1:
|
||||
cli
|
||||
push byte 0
|
||||
push byte %2
|
||||
jmp irq_common_stub
|
||||
%ENDMACRO
|
||||
|
||||
ISR_NOERRCODE 0
|
||||
ISR_NOERRCODE 1
|
||||
ISR_NOERRCODE 2
|
||||
ISR_NOERRCODE 3
|
||||
ISR_NOERRCODE 4
|
||||
ISR_NOERRCODE 5
|
||||
ISR_NOERRCODE 6
|
||||
ISR_NOERRCODE 7
|
||||
ISR_ERRCODE 8
|
||||
ISR_NOERRCODE 9
|
||||
ISR_ERRCODE 10
|
||||
ISR_ERRCODE 11
|
||||
ISR_ERRCODE 12
|
||||
ISR_ERRCODE 13
|
||||
ISR_ERRCODE 14
|
||||
ISR_NOERRCODE 15
|
||||
ISR_NOERRCODE 16
|
||||
ISR_NOERRCODE 17
|
||||
ISR_NOERRCODE 18
|
||||
ISR_NOERRCODE 19
|
||||
ISR_NOERRCODE 20
|
||||
ISR_NOERRCODE 21
|
||||
ISR_NOERRCODE 22
|
||||
ISR_NOERRCODE 23
|
||||
ISR_NOERRCODE 24
|
||||
ISR_NOERRCODE 25
|
||||
ISR_NOERRCODE 26
|
||||
ISR_NOERRCODE 27
|
||||
ISR_NOERRCODE 28
|
||||
ISR_NOERRCODE 29
|
||||
ISR_NOERRCODE 30
|
||||
ISR_NOERRCODE 31
|
||||
|
||||
IRQ 0, 32
|
||||
IRQ 1, 33
|
||||
IRQ 2, 34
|
||||
IRQ 3, 35
|
||||
IRQ 4, 36
|
||||
IRQ 5, 37
|
||||
IRQ 6, 38
|
||||
IRQ 7, 39
|
||||
IRQ 8, 40
|
||||
IRQ 9, 41
|
||||
IRQ 10, 42
|
||||
IRQ 11, 43
|
||||
IRQ 12, 44
|
||||
IRQ 13, 45
|
||||
IRQ 14, 46
|
||||
IRQ 15, 47
|
||||
|
||||
[EXTERN isr_handler]
|
||||
|
||||
isr_common_stub:
|
||||
pusha
|
||||
mov ax, ds
|
||||
push eax
|
||||
mov ax, 0x10
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov fs, ax
|
||||
mov gs, ax
|
||||
call isr_handler
|
||||
pop eax
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov fs, ax
|
||||
mov gs, ax
|
||||
popa
|
||||
add esp, 8
|
||||
sti
|
||||
iret
|
||||
|
||||
[EXTERN irq_handler]
|
||||
irq_common_stub:
|
||||
pusha
|
||||
mov ax, ds
|
||||
push eax
|
||||
mov ax, 0x10
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov fs, ax
|
||||
mov gs, ax
|
||||
call irq_handler
|
||||
pop ebx
|
||||
mov ds, bx
|
||||
mov es, bx
|
||||
mov fs, bx
|
||||
mov gs, bx
|
||||
popa
|
||||
add esp, 8
|
||||
sti
|
||||
iret
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include"include/initialize.h"
|
||||
#include"include/stdio.h"
|
||||
#include"include/ata.h"
|
||||
#include"include/fs.h"
|
||||
#include"include/fat12.h"
|
||||
#include"include/memory.h"
|
||||
#include"include/dt.h"
|
||||
#include"include/isr.h"
|
||||
#include"include/vga.h"
|
||||
#include"include/keyboard.h"
|
||||
#include"include/mouse.h"
|
||||
#include"include/timer.h"
|
||||
#include"include/rtc.h"
|
||||
#include"include/math.h"
|
||||
#include"include/pic.h"
|
||||
|
||||
#define GUI_MODE 0
|
||||
|
||||
//main function
|
||||
extern "C" int main() {
|
||||
printf("vimixOS\n");
|
||||
//initalize system resources
|
||||
initialize();
|
||||
vga_init();
|
||||
printf(">_");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,219 @@
|
|||
[BITS 32]
|
||||
;import the main function from kernel.cpp.
|
||||
[EXTERN modules]
|
||||
;call the function main.
|
||||
call modules
|
||||
;creates an infinite loop by jumping to the current memory address.
|
||||
jmp $
|
||||
|
||||
[GLOBAL memcpy_sse]
|
||||
memcpy_sse:
|
||||
push ebp
|
||||
mov ebp, esp
|
||||
push esi
|
||||
push edi
|
||||
pushf
|
||||
cld
|
||||
mov edi, [ebp + 8]
|
||||
mov esi, [ebp + 12]
|
||||
mov eax, [ebp + 16]
|
||||
mov ecx, eax
|
||||
shr ecx, 6
|
||||
jz .endloop64
|
||||
.loop64:
|
||||
prefetchnta [esi + 64]
|
||||
prefetchnta [esi + 96]
|
||||
movq mm1, [esi + 0]
|
||||
movq mm2, [esi + 8]
|
||||
movq mm3, [esi + 16]
|
||||
movq mm4, [esi + 24]
|
||||
movq mm5, [esi + 32]
|
||||
movq mm6, [esi + 40]
|
||||
movq mm7, [esi + 48]
|
||||
movq mm0, [esi + 56]
|
||||
movntq [edi + 0], mm1
|
||||
movntq [edi + 8], mm2
|
||||
movntq [edi + 16], mm3
|
||||
movntq [edi + 24], mm4
|
||||
movntq [edi + 32], mm5
|
||||
movntq [edi + 40], mm6
|
||||
movntq [edi + 48], mm7
|
||||
movntq [edi + 56], mm0
|
||||
add esi, 64
|
||||
add edi, 64
|
||||
loop .loop64
|
||||
emms
|
||||
.endloop64:
|
||||
mov ecx, eax
|
||||
and ecx, 0x3F
|
||||
shr ecx, 3
|
||||
jz .endloop8
|
||||
.loop8:
|
||||
movq mm1, [esi]
|
||||
movq [edi], mm1
|
||||
add esi, 8
|
||||
add edi, 8
|
||||
loop .loop8
|
||||
emms
|
||||
.endloop8:
|
||||
mov ecx, eax
|
||||
and ecx, 7
|
||||
repe movsb
|
||||
.done:
|
||||
popf
|
||||
pop edi
|
||||
pop esi
|
||||
mov esp, ebp
|
||||
pop ebp
|
||||
ret
|
||||
|
||||
[GLOBAL enable_sse]
|
||||
enable_sse:
|
||||
mov eax, cr0
|
||||
and ax, 0xFFFB
|
||||
or ax, 0x2
|
||||
mov cr0, eax
|
||||
mov eax, cr4
|
||||
or ax, 3 << 9
|
||||
mov cr4, eax
|
||||
ret
|
||||
|
||||
[GLOBAL gdt_flush]
|
||||
gdt_flush:
|
||||
mov eax, [esp+4]
|
||||
lgdt [eax]
|
||||
mov eax, 0x10
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov fs, ax
|
||||
mov gs, ax
|
||||
mov ss, ax
|
||||
jmp 0x08:.flush
|
||||
.flush:
|
||||
ret
|
||||
|
||||
[GLOBAL idt_flush]
|
||||
idt_flush:
|
||||
mov eax, [esp+4]
|
||||
lidt [eax]
|
||||
sti
|
||||
ret
|
||||
|
||||
%MACRO ISR_NOERRCODE 1
|
||||
[GLOBAL isr%1]
|
||||
isr%1:
|
||||
cli
|
||||
push byte 0
|
||||
push byte %1
|
||||
jmp isr_common_stub
|
||||
%ENDMACRO
|
||||
|
||||
%MACRO ISR_ERRCODE 1
|
||||
[GLOBAL isr%1]
|
||||
isr%1:
|
||||
cli
|
||||
push byte %1
|
||||
jmp isr_common_stub
|
||||
%ENDMACRO
|
||||
|
||||
%MACRO IRQ 2
|
||||
[GLOBAL irq%1]
|
||||
irq%1:
|
||||
cli
|
||||
push byte 0
|
||||
push byte %2
|
||||
jmp irq_common_stub
|
||||
%ENDMACRO
|
||||
|
||||
ISR_NOERRCODE 0
|
||||
ISR_NOERRCODE 1
|
||||
ISR_NOERRCODE 2
|
||||
ISR_NOERRCODE 3
|
||||
ISR_NOERRCODE 4
|
||||
ISR_NOERRCODE 5
|
||||
ISR_NOERRCODE 6
|
||||
ISR_NOERRCODE 7
|
||||
ISR_ERRCODE 8
|
||||
ISR_NOERRCODE 9
|
||||
ISR_ERRCODE 10
|
||||
ISR_ERRCODE 11
|
||||
ISR_ERRCODE 12
|
||||
ISR_ERRCODE 13
|
||||
ISR_ERRCODE 14
|
||||
ISR_NOERRCODE 15
|
||||
ISR_NOERRCODE 16
|
||||
ISR_NOERRCODE 17
|
||||
ISR_NOERRCODE 18
|
||||
ISR_NOERRCODE 19
|
||||
ISR_NOERRCODE 20
|
||||
ISR_NOERRCODE 21
|
||||
ISR_NOERRCODE 22
|
||||
ISR_NOERRCODE 23
|
||||
ISR_NOERRCODE 24
|
||||
ISR_NOERRCODE 25
|
||||
ISR_NOERRCODE 26
|
||||
ISR_NOERRCODE 27
|
||||
ISR_NOERRCODE 28
|
||||
ISR_NOERRCODE 29
|
||||
ISR_NOERRCODE 30
|
||||
ISR_NOERRCODE 31
|
||||
|
||||
IRQ 0, 32
|
||||
IRQ 1, 33
|
||||
IRQ 2, 34
|
||||
IRQ 3, 35
|
||||
IRQ 4, 36
|
||||
IRQ 5, 37
|
||||
IRQ 6, 38
|
||||
IRQ 7, 39
|
||||
IRQ 8, 40
|
||||
IRQ 9, 41
|
||||
IRQ 10, 42
|
||||
IRQ 11, 43
|
||||
IRQ 12, 44
|
||||
IRQ 13, 45
|
||||
IRQ 14, 46
|
||||
IRQ 15, 47
|
||||
|
||||
[EXTERN isr_handler]
|
||||
|
||||
isr_common_stub:
|
||||
pusha
|
||||
mov ax, ds
|
||||
push eax
|
||||
mov ax, 0x10
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov fs, ax
|
||||
mov gs, ax
|
||||
call isr_handler
|
||||
pop eax
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov fs, ax
|
||||
mov gs, ax
|
||||
popa
|
||||
add esp, 8
|
||||
sti
|
||||
iret
|
||||
|
||||
[EXTERN irq_handler]
|
||||
irq_common_stub:
|
||||
pusha
|
||||
mov ax, ds
|
||||
push eax
|
||||
mov ax, 0x10
|
||||
mov ds, ax
|
||||
mov es, ax
|
||||
mov fs, ax
|
||||
mov gs, ax
|
||||
call irq_handler
|
||||
pop ebx
|
||||
mov ds, bx
|
||||
mov es, bx
|
||||
mov fs, bx
|
||||
mov gs, bx
|
||||
popa
|
||||
add esp, 8
|
||||
sti
|
||||
iret
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
#include"include/initialize.h"
|
||||
#include"include/stdio.h"
|
||||
#include"include/ata.h"
|
||||
#include"include/fs.h"
|
||||
#include"include/fat12.h"
|
||||
#include"include/memory.h"
|
||||
#include"include/dt.h"
|
||||
#include"include/isr.h"
|
||||
#include"include/keyboard.h"
|
||||
#include"include/mouse.h"
|
||||
#include"include/timer.h"
|
||||
#include"include/rtc.h"
|
||||
#include"include/math.h"
|
||||
#include"include/pic.h"
|
||||
#include"include/vga.h"
|
||||
|
||||
extern "C" void modules(){
|
||||
initialize();
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
#include"shell.h"
|
||||
|
||||
int shell(){
|
||||
while(true){
|
||||
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
#!/bin/bash
|
||||
|
||||
BINUTILS_VERSION="${BINUTILS_VERSION:-2.37}"
|
||||
GCC_VERSION="${GCC_VERSION:-11.2.0}"
|
||||
|
||||
BINUTILS_URL="https://ftp.gnu.org/gnu/binutils/binutils-${BINUTILS_VERSION}.tar.xz"
|
||||
GCC_URL="https://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/gcc-${GCC_VERSION}.tar.xz"
|
||||
|
||||
TARGET=i386-elf
|
||||
|
||||
# ---------------------------
|
||||
|
||||
set -e
|
||||
|
||||
TOOLCHAINS_DIR=$PWD/tools # burayı değiştirebilirsiniz
|
||||
OPERATION='build'
|
||||
|
||||
while test $# -gt 0
|
||||
do
|
||||
case "$1" in
|
||||
-c) OPERATION='clean'
|
||||
;;
|
||||
*) TOOLCHAINS_DIR="$1"
|
||||
;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
|
||||
if [ -z "$TOOLCHAINS_DIR" ]; then
|
||||
echo "Missing arg: toolchains directory"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
pushd "$TOOLCHAINS_DIR"
|
||||
TOOLCHAIN_PREFIX="$TOOLCHAINS_DIR/$TARGET"
|
||||
|
||||
if [ "$OPERATION" = "build" ]; then
|
||||
|
||||
# Download and build binutils
|
||||
BINUTILS_SRC="binutils-${BINUTILS_VERSION}"
|
||||
BINUTILS_BUILD="binutils-build-${BINUTILS_VERSION}"
|
||||
|
||||
wget ${BINUTILS_URL}
|
||||
tar -xf binutils-${BINUTILS_VERSION}.tar.xz
|
||||
|
||||
mkdir -p ${BINUTILS_BUILD}
|
||||
pushd ${BINUTILS_BUILD}
|
||||
../binutils-${BINUTILS_VERSION}/configure \
|
||||
--prefix="${TOOLCHAIN_PREFIX}" \
|
||||
--target=${TARGET} \
|
||||
--with-sysroot \
|
||||
--disable-nls \
|
||||
--disable-werror
|
||||
make -j$(nproc) # j sizin threads sayınızdır `nproc` ile bulabilirsiniz
|
||||
make install
|
||||
popd
|
||||
|
||||
# Download and build GCC
|
||||
GCC_SRC="gcc-${GCC_VERSION}"
|
||||
GCC_BUILD="gcc-build-${GCC_VERSION}"
|
||||
|
||||
wget ${GCC_URL}
|
||||
tar -xf gcc-${GCC_VERSION}.tar.xz
|
||||
mkdir -p ${GCC_BUILD}
|
||||
pushd ${GCC_BUILD}
|
||||
../gcc-${GCC_VERSION}/configure \
|
||||
--prefix="${TOOLCHAIN_PREFIX}" \
|
||||
--target=${TARGET} \
|
||||
--disable-nls \
|
||||
--enable-languages=c,c++ \
|
||||
--without-headers
|
||||
make -j$(nproc) all-gcc all-target-libgcc
|
||||
make install-gcc install-target-libgcc
|
||||
popd
|
||||
rm *.tar.xz
|
||||
rm ./toolchain
|
||||
|
||||
elif [ "$OPERATION" = "clean" ]; then
|
||||
rm -rf *
|
||||
fi
|
||||
Loading…
Reference in New Issue